Adding upstream version 3.3.0+dfsg1.upstream/3.3.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

9 files changed, 6193 insertions, 0 deletions

diff --git a/channels/urbdrc/client/CMakeLists.txt b/channels/urbdrc/client/CMakeLists.txt
new file mode 100644
index 0000000..1787024
--- /dev/null
+++ b/channels/urbdrc/client/CMakeLists.txt
@@ -0,0 +1,40 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP cmake build script
+#
+# Copyright 2012 Atrust corp.
+# Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+define_channel_client("urbdrc")
+
+set(${MODULE_PREFIX}_SRCS
+	data_transfer.c
+	data_transfer.h
+	urbdrc_main.c
+	urbdrc_main.h
+)
+
+set(${MODULE_PREFIX}_LIBS
+	winpr
+	freerdp
+	urbdrc-common
+)
+if (UDEV_FOUND AND UDEV_LIBRARIES)
+	list(APPEND ${MODULE_PREFIX}_LIBS ${UDEV_LIBRARIES})
+endif()
+
+add_channel_client_library(${MODULE_PREFIX} ${MODULE_NAME} ${CHANNEL_NAME} TRUE "DVCPluginEntry")
+
+# libusb subsystem
+add_channel_client_subsystem(${MODULE_PREFIX} ${CHANNEL_NAME} "libusb" "")
diff --git a/channels/urbdrc/client/data_transfer.c b/channels/urbdrc/client/data_transfer.c
new file mode 100644
index 0000000..7a7e5a2
--- /dev/null
+++ b/channels/urbdrc/client/data_transfer.c
@@ -0,0 +1,1949 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX USB Redirection
+ *
+ * Copyright 2012 Atrust corp.
+ * Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <winpr/sysinfo.h>
+
+#include <urbdrc_helpers.h>
+
+#include "urbdrc_types.h"
+#include "data_transfer.h"
+
+static void usb_process_get_port_status(IUDEVICE* pdev, wStream* out)
+{
+	int bcdUSB = pdev->query_device_descriptor(pdev, BCD_USB);
+
+	switch (bcdUSB)
+	{
+		case USB_v1_0:
+			Stream_Write_UINT32(out, 0x303);
+			break;
+
+		case USB_v1_1:
+			Stream_Write_UINT32(out, 0x103);
+			break;
+
+		case USB_v2_0:
+			Stream_Write_UINT32(out, 0x503);
+			break;
+
+		default:
+			Stream_Write_UINT32(out, 0x503);
+			break;
+	}
+}
+
+static UINT urb_write_completion(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback, BOOL noAck,
+                                 wStream* out, UINT32 InterfaceId, UINT32 MessageId,
+                                 UINT32 RequestId, UINT32 usbd_status, UINT32 OutputBufferSize)
+{
+	if (!out)
+		return ERROR_INVALID_PARAMETER;
+
+	if (Stream_Capacity(out) < OutputBufferSize + 36)
+	{
+		Stream_Free(out, TRUE);
+		return ERROR_INVALID_PARAMETER;
+	}
+
+	Stream_SetPosition(out, 0);
+	Stream_Write_UINT32(out, InterfaceId); /** interface */
+	Stream_Write_UINT32(out, MessageId);   /** message id */
+
+	if (OutputBufferSize != 0)
+		Stream_Write_UINT32(out, URB_COMPLETION);
+	else
+		Stream_Write_UINT32(out, URB_COMPLETION_NO_DATA);
+
+	Stream_Write_UINT32(out, RequestId); /** RequestId */
+	Stream_Write_UINT32(out, 8);         /** CbTsUrbResult */
+	/** TsUrbResult TS_URB_RESULT_HEADER */
+	Stream_Write_UINT16(out, 8);                /** Size */
+	Stream_Write_UINT16(out, 0);                /* Padding */
+	Stream_Write_UINT32(out, usbd_status);      /** UsbdStatus */
+	Stream_Write_UINT32(out, 0);                /** HResult */
+	Stream_Write_UINT32(out, OutputBufferSize); /** OutputBufferSize */
+	Stream_Seek(out, OutputBufferSize);
+
+	if (!noAck)
+		return stream_write_and_free(callback->plugin, callback->channel, out);
+	else
+		Stream_Free(out, TRUE);
+
+	return ERROR_SUCCESS;
+}
+
+static wStream* urb_create_iocompletion(UINT32 InterfaceField, UINT32 MessageId, UINT32 RequestId,
+                                        UINT32 OutputBufferSize)
+{
+	const UINT32 InterfaceId = (STREAM_ID_PROXY << 30) | (InterfaceField & 0x3FFFFFFF);
+
+#if UINT32_MAX >= SIZE_MAX
+	if (OutputBufferSize > UINT32_MAX - 28ull)
+		return NULL;
+#endif
+
+	wStream* out = Stream_New(NULL, OutputBufferSize + 28ull);
+
+	if (!out)
+		return NULL;
+
+	Stream_Write_UINT32(out, InterfaceId);          /** interface */
+	Stream_Write_UINT32(out, MessageId);            /** message id */
+	Stream_Write_UINT32(out, IOCONTROL_COMPLETION); /** function id */
+	Stream_Write_UINT32(out, RequestId);            /** RequestId */
+	Stream_Write_UINT32(out, USBD_STATUS_SUCCESS);  /** HResult */
+	Stream_Write_UINT32(out, OutputBufferSize);     /** Information */
+	Stream_Write_UINT32(out, OutputBufferSize);     /** OutputBufferSize */
+	return out;
+}
+
+static UINT urbdrc_process_register_request_callback(IUDEVICE* pdev,
+                                                     GENERIC_CHANNEL_CALLBACK* callback, wStream* s,
+                                                     IUDEVMAN* udevman)
+{
+	UINT32 NumRequestCompletion = 0;
+	UINT32 RequestCompletion = 0;
+	URBDRC_PLUGIN* urbdrc = NULL;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	WLog_Print(urbdrc->log, WLOG_DEBUG, "urbdrc_process_register_request_callback");
+
+	if (Stream_GetRemainingLength(s) >= 8)
+	{
+		Stream_Read_UINT32(s, NumRequestCompletion); /** must be 1 */
+		/** RequestCompletion:
+		 *   unique Request Completion interface for the client to use */
+		Stream_Read_UINT32(s, RequestCompletion);
+		pdev->set_ReqCompletion(pdev, RequestCompletion);
+	}
+	else if (Stream_GetRemainingLength(s) >= 4) /** Unregister the device */
+	{
+		Stream_Read_UINT32(s, RequestCompletion);
+
+		if (pdev->get_ReqCompletion(pdev) == RequestCompletion)
+			pdev->setChannelClosed(pdev);
+	}
+	else
+		return ERROR_INVALID_DATA;
+
+	return ERROR_SUCCESS;
+}
+
+static UINT urbdrc_process_cancel_request(IUDEVICE* pdev, wStream* s, IUDEVMAN* udevman)
+{
+	UINT32 CancelId = 0;
+	URBDRC_PLUGIN* urbdrc = NULL;
+
+	if (!s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)udevman->plugin;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT32(s, CancelId);
+	WLog_Print(urbdrc->log, WLOG_DEBUG, "CANCEL_REQUEST: CancelId=%08" PRIx32 "", CancelId);
+
+	if (pdev->cancel_transfer_request(pdev, CancelId) < 0)
+		return ERROR_INTERNAL_ERROR;
+
+	return ERROR_SUCCESS;
+}
+
+static UINT urbdrc_process_retract_device_request(IUDEVICE* pdev, wStream* s, IUDEVMAN* udevman)
+{
+	UINT32 Reason = 0;
+	URBDRC_PLUGIN* urbdrc = NULL;
+
+	if (!s || !udevman)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)udevman->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT32(s, Reason); /** Reason */
+
+	switch (Reason)
+	{
+		case UsbRetractReason_BlockedByPolicy:
+			WLog_Print(urbdrc->log, WLOG_DEBUG,
+			           "UsbRetractReason_BlockedByPolicy: now it is not support");
+			return ERROR_ACCESS_DENIED;
+
+		default:
+			WLog_Print(urbdrc->log, WLOG_DEBUG,
+			           "urbdrc_process_retract_device_request: Unknown Reason %" PRIu32 "", Reason);
+			return ERROR_ACCESS_DENIED;
+	}
+
+	return ERROR_SUCCESS;
+}
+
+static UINT urbdrc_process_io_control(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback,
+                                      wStream* s, UINT32 MessageId, IUDEVMAN* udevman)
+{
+	UINT32 InterfaceId = 0;
+	UINT32 IoControlCode = 0;
+	UINT32 InputBufferSize = 0;
+	UINT32 OutputBufferSize = 0;
+	UINT32 RequestId = 0;
+	UINT32 usbd_status = USBD_STATUS_SUCCESS;
+	wStream* out = NULL;
+	int success = 0;
+	URBDRC_PLUGIN* urbdrc = NULL;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT32(s, IoControlCode);
+	Stream_Read_UINT32(s, InputBufferSize);
+
+	if (!Stream_SafeSeek(s, InputBufferSize))
+		return ERROR_INVALID_DATA;
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 8ULL))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT32(s, OutputBufferSize);
+	Stream_Read_UINT32(s, RequestId);
+
+	if (OutputBufferSize > UINT32_MAX - 4)
+		return ERROR_INVALID_DATA;
+
+	InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
+	out = urb_create_iocompletion(InterfaceId, MessageId, RequestId, OutputBufferSize + 4);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	switch (IoControlCode)
+	{
+		case IOCTL_INTERNAL_USB_SUBMIT_URB: /** 0x00220003 */
+			WLog_Print(urbdrc->log, WLOG_DEBUG, "ioctl: IOCTL_INTERNAL_USB_SUBMIT_URB");
+			WLog_Print(urbdrc->log, WLOG_ERROR,
+			           " Function IOCTL_INTERNAL_USB_SUBMIT_URB: Unchecked");
+			break;
+
+		case IOCTL_INTERNAL_USB_RESET_PORT: /** 0x00220007 */
+			WLog_Print(urbdrc->log, WLOG_DEBUG, "ioctl: IOCTL_INTERNAL_USB_RESET_PORT");
+			break;
+
+		case IOCTL_INTERNAL_USB_GET_PORT_STATUS: /** 0x00220013 */
+			WLog_Print(urbdrc->log, WLOG_DEBUG, "ioctl: IOCTL_INTERNAL_USB_GET_PORT_STATUS");
+			success = pdev->query_device_port_status(pdev, &usbd_status, &OutputBufferSize,
+			                                         Stream_Pointer(out));
+
+			if (success)
+			{
+				if (!Stream_SafeSeek(out, OutputBufferSize))
+				{
+					Stream_Free(out, TRUE);
+					return ERROR_INVALID_DATA;
+				}
+
+				if (pdev->isExist(pdev) == 0)
+					Stream_Write_UINT32(out, 0);
+				else
+					usb_process_get_port_status(pdev, out);
+			}
+
+			break;
+
+		case IOCTL_INTERNAL_USB_CYCLE_PORT: /** 0x0022001F */
+			WLog_Print(urbdrc->log, WLOG_DEBUG, "ioctl: IOCTL_INTERNAL_USB_CYCLE_PORT");
+			WLog_Print(urbdrc->log, WLOG_ERROR,
+			           " Function IOCTL_INTERNAL_USB_CYCLE_PORT: Unchecked");
+			break;
+
+		case IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION: /** 0x00220027 */
+			WLog_Print(urbdrc->log, WLOG_DEBUG,
+			           "ioctl: IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION");
+			WLog_Print(urbdrc->log, WLOG_ERROR,
+			           " Function IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION: Unchecked");
+			break;
+
+		default:
+			WLog_Print(urbdrc->log, WLOG_DEBUG,
+			           "urbdrc_process_io_control: unknown IoControlCode 0x%" PRIX32 "",
+			           IoControlCode);
+			Stream_Free(out, TRUE);
+			return ERROR_INVALID_OPERATION;
+	}
+
+	return stream_write_and_free(callback->plugin, callback->channel, out);
+}
+
+static UINT urbdrc_process_internal_io_control(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback,
+                                               wStream* s, UINT32 MessageId, IUDEVMAN* udevman)
+{
+	wStream* out = NULL;
+	UINT32 IoControlCode = 0;
+	UINT32 InterfaceId = 0;
+	UINT32 InputBufferSize = 0;
+	UINT32 OutputBufferSize = 0;
+	UINT32 RequestId = 0;
+	UINT32 frames = 0;
+
+	if (!pdev || !callback || !s || !udevman)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT32(s, IoControlCode);
+	Stream_Read_UINT32(s, InputBufferSize);
+
+	if (!Stream_SafeSeek(s, InputBufferSize))
+		return ERROR_INVALID_DATA;
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 8ULL))
+		return ERROR_INVALID_DATA;
+	Stream_Read_UINT32(s, OutputBufferSize);
+	Stream_Read_UINT32(s, RequestId);
+	InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
+	// TODO: Implement control code.
+	/** Fixme: Currently this is a FALSE bustime... */
+	frames = GetTickCount();
+	out = urb_create_iocompletion(InterfaceId, MessageId, RequestId, 4);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Write_UINT32(out, frames); /** OutputBuffer */
+	return stream_write_and_free(callback->plugin, callback->channel, out);
+}
+
+static UINT urbdrc_process_query_device_text(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback,
+                                             wStream* s, UINT32 MessageId, IUDEVMAN* udevman)
+{
+	UINT32 out_size = 0;
+	UINT32 TextType = 0;
+	UINT32 LocaleId = 0;
+	UINT32 InterfaceId = 0;
+	UINT8 bufferSize = 0xFF;
+	UINT32 hr = 0;
+	wStream* out = NULL;
+	BYTE DeviceDescription[0x100] = { 0 };
+
+	if (!pdev || !callback || !s || !udevman)
+		return ERROR_INVALID_PARAMETER;
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT32(s, TextType);
+	Stream_Read_UINT32(s, LocaleId);
+	if (LocaleId > UINT16_MAX)
+		return ERROR_INVALID_DATA;
+
+	hr = pdev->control_query_device_text(pdev, TextType, (UINT16)LocaleId, &bufferSize,
+	                                     DeviceDescription);
+	InterfaceId = ((STREAM_ID_STUB << 30) | pdev->get_UsbDevice(pdev));
+	out_size = 16 + bufferSize;
+
+	if (bufferSize != 0)
+		out_size += 2;
+
+	out = Stream_New(NULL, out_size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Write_UINT32(out, InterfaceId);            /** interface */
+	Stream_Write_UINT32(out, MessageId);              /** message id */
+	Stream_Write_UINT32(out, bufferSize / 2);         /** cchDeviceDescription in WCHAR */
+	Stream_Write(out, DeviceDescription, bufferSize); /* '\0' terminated unicode */
+	Stream_Write_UINT32(out, hr);                     /** HResult */
+	return stream_write_and_free(callback->plugin, callback->channel, out);
+}
+
+static void func_select_all_interface_for_msconfig(IUDEVICE* pdev,
+                                                   MSUSB_CONFIG_DESCRIPTOR* MsConfig)
+{
+	MSUSB_INTERFACE_DESCRIPTOR** MsInterfaces = MsConfig->MsInterfaces;
+	BYTE InterfaceNumber = 0;
+	BYTE AlternateSetting = 0;
+	UINT32 NumInterfaces = MsConfig->NumInterfaces;
+
+	for (UINT32 inum = 0; inum < NumInterfaces; inum++)
+	{
+		InterfaceNumber = MsInterfaces[inum]->InterfaceNumber;
+		AlternateSetting = MsInterfaces[inum]->AlternateSetting;
+		pdev->select_interface(pdev, InterfaceNumber, AlternateSetting);
+	}
+}
+
+static UINT urb_select_configuration(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback, wStream* s,
+                                     UINT32 RequestField, UINT32 MessageId, IUDEVMAN* udevman,
+                                     int transferDir)
+{
+	MSUSB_CONFIG_DESCRIPTOR* MsConfig = NULL;
+	size_t out_size = 0;
+	UINT32 InterfaceId = 0;
+	UINT32 NumInterfaces = 0;
+	UINT32 usbd_status = 0;
+	BYTE ConfigurationDescriptorIsValid = 0;
+	wStream* out = NULL;
+	int MsOutSize = 0;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	const BOOL noAck = (RequestField & 0x80000000U) != 0;
+	const UINT32 RequestId = RequestField & 0x7FFFFFFF;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (transferDir == 0)
+	{
+		WLog_Print(urbdrc->log, WLOG_ERROR, "urb_select_configuration: unsupported transfer out");
+		return ERROR_INVALID_PARAMETER;
+	}
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
+		return ERROR_INVALID_DATA;
+
+	InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
+	Stream_Read_UINT8(s, ConfigurationDescriptorIsValid);
+	Stream_Seek(s, 3); /* Padding */
+	Stream_Read_UINT32(s, NumInterfaces);
+
+	/** if ConfigurationDescriptorIsValid is zero, then just do nothing.*/
+	if (ConfigurationDescriptorIsValid)
+	{
+		/* parser data for struct config */
+		MsConfig = msusb_msconfig_read(s, NumInterfaces);
+
+		if (!MsConfig)
+			return ERROR_INVALID_DATA;
+
+		/* select config */
+		pdev->select_configuration(pdev, MsConfig->bConfigurationValue);
+		/* select all interface */
+		func_select_all_interface_for_msconfig(pdev, MsConfig);
+		/* complete configuration setup */
+		if (!pdev->complete_msconfig_setup(pdev, MsConfig))
+		{
+			msusb_msconfig_free(MsConfig);
+			MsConfig = NULL;
+		}
+	}
+
+	if (MsConfig)
+		MsOutSize = MsConfig->MsOutSize;
+
+	if (MsOutSize > 0)
+	{
+		if ((size_t)MsOutSize > SIZE_MAX - 36)
+			return ERROR_INVALID_DATA;
+
+		out_size = 36 + MsOutSize;
+	}
+	else
+		out_size = 44;
+
+	out = Stream_New(NULL, out_size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Write_UINT32(out, InterfaceId);            /** interface */
+	Stream_Write_UINT32(out, MessageId);              /** message id */
+	Stream_Write_UINT32(out, URB_COMPLETION_NO_DATA); /** function id */
+	Stream_Write_UINT32(out, RequestId);              /** RequestId */
+
+	if (MsOutSize > 0)
+	{
+		/** CbTsUrbResult */
+		Stream_Write_UINT32(out, 8 + MsOutSize);
+		/** TS_URB_RESULT_HEADER Size*/
+		Stream_Write_UINT16(out, 8 + MsOutSize);
+	}
+	else
+	{
+		Stream_Write_UINT32(out, 16);
+		Stream_Write_UINT16(out, 16);
+	}
+
+	/** Padding, MUST be ignored upon receipt */
+	Stream_Write_UINT16(out, TS_URB_SELECT_CONFIGURATION);
+	Stream_Write_UINT32(out, usbd_status); /** UsbdStatus */
+
+	/** TS_URB_SELECT_CONFIGURATION_RESULT */
+	if (MsOutSize > 0)
+		msusb_msconfig_write(MsConfig, out);
+	else
+	{
+		Stream_Write_UINT32(out, 0);             /** ConfigurationHandle */
+		Stream_Write_UINT32(out, NumInterfaces); /** NumInterfaces */
+	}
+
+	Stream_Write_UINT32(out, 0); /** HResult */
+	Stream_Write_UINT32(out, 0); /** OutputBufferSize */
+
+	if (!noAck)
+		return stream_write_and_free(callback->plugin, callback->channel, out);
+	else
+		Stream_Free(out, TRUE);
+
+	return ERROR_SUCCESS;
+}
+
+static UINT urb_select_interface(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback, wStream* s,
+                                 UINT32 RequestField, UINT32 MessageId, IUDEVMAN* udevman,
+                                 int transferDir)
+{
+	MSUSB_CONFIG_DESCRIPTOR* MsConfig = NULL;
+	MSUSB_INTERFACE_DESCRIPTOR* MsInterface = NULL;
+	UINT32 out_size = 0;
+	UINT32 InterfaceId = 0;
+	UINT32 ConfigurationHandle = 0;
+	UINT32 OutputBufferSize = 0;
+	BYTE InterfaceNumber = 0;
+	wStream* out = NULL;
+	UINT32 interface_size = 0;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	const BOOL noAck = (RequestField & 0x80000000U) != 0;
+	const UINT32 RequestId = RequestField & 0x7FFFFFFF;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (transferDir == 0)
+	{
+		WLog_Print(urbdrc->log, WLOG_ERROR, "urb_select_interface: not support transfer out");
+		return ERROR_INVALID_PARAMETER;
+	}
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return ERROR_INVALID_DATA;
+
+	InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
+	Stream_Read_UINT32(s, ConfigurationHandle);
+	MsInterface = msusb_msinterface_read(s);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4) || !MsInterface)
+	{
+		msusb_msinterface_free(MsInterface);
+		return ERROR_INVALID_DATA;
+	}
+
+	Stream_Read_UINT32(s, OutputBufferSize);
+	pdev->select_interface(pdev, MsInterface->InterfaceNumber, MsInterface->AlternateSetting);
+	/* replace device's MsInterface */
+	MsConfig = pdev->get_MsConfig(pdev);
+	InterfaceNumber = MsInterface->InterfaceNumber;
+	if (!msusb_msinterface_replace(MsConfig, InterfaceNumber, MsInterface))
+	{
+		msusb_msconfig_free(MsConfig);
+		return ERROR_BAD_CONFIGURATION;
+	}
+	/* complete configuration setup */
+	if (!pdev->complete_msconfig_setup(pdev, MsConfig))
+	{
+		msusb_msconfig_free(MsConfig);
+		return ERROR_BAD_CONFIGURATION;
+	}
+	MsInterface = MsConfig->MsInterfaces[InterfaceNumber];
+	interface_size = 16 + (MsInterface->NumberOfPipes * 20);
+	out_size = 36 + interface_size;
+	out = Stream_New(NULL, out_size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Write_UINT32(out, InterfaceId);            /** interface */
+	Stream_Write_UINT32(out, MessageId);              /** message id */
+	Stream_Write_UINT32(out, URB_COMPLETION_NO_DATA); /** function id */
+	Stream_Write_UINT32(out, RequestId);              /** RequestId */
+	Stream_Write_UINT32(out, 8 + interface_size);     /** CbTsUrbResult */
+	/** TS_URB_RESULT_HEADER */
+	Stream_Write_UINT16(out, 8 + interface_size); /** Size */
+	/** Padding, MUST be ignored upon receipt */
+	Stream_Write_UINT16(out, TS_URB_SELECT_INTERFACE);
+	Stream_Write_UINT32(out, USBD_STATUS_SUCCESS); /** UsbdStatus */
+	/** TS_URB_SELECT_INTERFACE_RESULT */
+	msusb_msinterface_write(MsInterface, out);
+	Stream_Write_UINT32(out, 0); /** HResult */
+	Stream_Write_UINT32(out, 0); /** OutputBufferSize */
+
+	if (!noAck)
+		return stream_write_and_free(callback->plugin, callback->channel, out);
+	else
+		Stream_Free(out, TRUE);
+
+	return ERROR_SUCCESS;
+}
+
+static UINT urb_control_transfer(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback, wStream* s,
+                                 UINT32 RequestField, UINT32 MessageId, IUDEVMAN* udevman,
+                                 int transferDir, int External)
+{
+	UINT32 out_size = 0;
+	UINT32 InterfaceId = 0;
+	UINT32 EndpointAddress = 0;
+	UINT32 PipeHandle = 0;
+	UINT32 TransferFlags = 0;
+	UINT32 OutputBufferSize = 0;
+	UINT32 usbd_status = 0;
+	UINT32 Timeout = 0;
+	BYTE bmRequestType = 0;
+	BYTE Request = 0;
+	UINT16 Value = 0;
+	UINT16 Index = 0;
+	UINT16 length = 0;
+	BYTE* buffer = NULL;
+	wStream* out = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	const BOOL noAck = (RequestField & 0x80000000U) != 0;
+	const UINT32 RequestId = RequestField & 0x7FFFFFFF;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
+		return ERROR_INVALID_DATA;
+
+	InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
+	Stream_Read_UINT32(s, PipeHandle);
+	Stream_Read_UINT32(s, TransferFlags); /** TransferFlags */
+	EndpointAddress = (PipeHandle & 0x000000ff);
+	Timeout = 2000;
+
+	switch (External)
+	{
+		case URB_CONTROL_TRANSFER_EXTERNAL:
+			if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+				return ERROR_INVALID_DATA;
+
+			Stream_Read_UINT32(s, Timeout); /** TransferFlags */
+			break;
+
+		case URB_CONTROL_TRANSFER_NONEXTERNAL:
+			break;
+	}
+
+	/** SetupPacket 8 bytes */
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 12))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT8(s, bmRequestType);
+	Stream_Read_UINT8(s, Request);
+	Stream_Read_UINT16(s, Value);
+	Stream_Read_UINT16(s, Index);
+	Stream_Read_UINT16(s, length);
+	Stream_Read_UINT32(s, OutputBufferSize);
+
+	if (length != OutputBufferSize)
+	{
+		WLog_Print(urbdrc->log, WLOG_ERROR, "urb_control_transfer ERROR: buf != length");
+		return ERROR_INVALID_DATA;
+	}
+
+	out_size = 36 + OutputBufferSize;
+	out = Stream_New(NULL, out_size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Seek(out, 36);
+	/** Get Buffer Data */
+	buffer = Stream_Pointer(out);
+
+	if (transferDir == USBD_TRANSFER_DIRECTION_OUT)
+	{
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, OutputBufferSize))
+			return ERROR_INVALID_DATA;
+		Stream_Copy(s, out, OutputBufferSize);
+	}
+
+	/**  process TS_URB_CONTROL_TRANSFER */
+	if (!pdev->control_transfer(pdev, RequestId, EndpointAddress, TransferFlags, bmRequestType,
+	                            Request, Value, Index, &usbd_status, &OutputBufferSize, buffer,
+	                            Timeout))
+	{
+		WLog_Print(urbdrc->log, WLOG_ERROR, "control_transfer failed");
+		Stream_Free(out, TRUE);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	return urb_write_completion(pdev, callback, noAck, out, InterfaceId, MessageId, RequestId,
+	                            usbd_status, OutputBufferSize);
+}
+
+static void urb_bulk_transfer_cb(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback, wStream* out,
+                                 UINT32 InterfaceId, BOOL noAck, UINT32 MessageId, UINT32 RequestId,
+                                 UINT32 NumberOfPackets, UINT32 status, UINT32 StartFrame,
+                                 UINT32 ErrorCount, UINT32 OutputBufferSize)
+{
+	if (!pdev->isChannelClosed(pdev))
+		urb_write_completion(pdev, callback, noAck, out, InterfaceId, MessageId, RequestId, status,
+		                     OutputBufferSize);
+	else
+		Stream_Free(out, TRUE);
+}
+
+static UINT urb_bulk_or_interrupt_transfer(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback,
+                                           wStream* s, UINT32 RequestField, UINT32 MessageId,
+                                           IUDEVMAN* udevman, int transferDir)
+{
+	UINT32 EndpointAddress = 0;
+	UINT32 PipeHandle = 0;
+	UINT32 TransferFlags = 0;
+	UINT32 OutputBufferSize = 0;
+	const BOOL noAck = (RequestField & 0x80000000U) != 0;
+	const UINT32 RequestId = RequestField & 0x7FFFFFFF;
+
+	if (!pdev || !callback || !s || !udevman)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 12))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT32(s, PipeHandle);
+	Stream_Read_UINT32(s, TransferFlags); /** TransferFlags */
+	Stream_Read_UINT32(s, OutputBufferSize);
+	EndpointAddress = (PipeHandle & 0x000000ff);
+
+	if (transferDir == USBD_TRANSFER_DIRECTION_OUT)
+	{
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, OutputBufferSize))
+		{
+			return ERROR_INVALID_DATA;
+		}
+	}
+
+	/**  process TS_URB_BULK_OR_INTERRUPT_TRANSFER */
+	return pdev->bulk_or_interrupt_transfer(
+	    pdev, callback, MessageId, RequestId, EndpointAddress, TransferFlags, noAck,
+	    OutputBufferSize, (transferDir == USBD_TRANSFER_DIRECTION_OUT) ? Stream_Pointer(s) : NULL,
+	    urb_bulk_transfer_cb, 10000);
+}
+
+static void urb_isoch_transfer_cb(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback, wStream* out,
+                                  UINT32 InterfaceId, BOOL noAck, UINT32 MessageId,
+                                  UINT32 RequestId, UINT32 NumberOfPackets, UINT32 status,
+                                  UINT32 StartFrame, UINT32 ErrorCount, UINT32 OutputBufferSize)
+{
+	if (!noAck)
+	{
+		UINT32 packetSize = (status == 0) ? NumberOfPackets * 12 : 0;
+		Stream_SetPosition(out, 0);
+		/* fill the send data */
+		Stream_Write_UINT32(out, InterfaceId); /** interface */
+		Stream_Write_UINT32(out, MessageId);   /** message id */
+
+		if (OutputBufferSize == 0)
+			Stream_Write_UINT32(out, URB_COMPLETION_NO_DATA); /** function id */
+		else
+			Stream_Write_UINT32(out, URB_COMPLETION); /** function id */
+
+		Stream_Write_UINT32(out, RequestId);       /** RequestId */
+		Stream_Write_UINT32(out, 20 + packetSize); /** CbTsUrbResult */
+		/** TsUrbResult TS_URB_RESULT_HEADER */
+		Stream_Write_UINT16(out, 20 + packetSize); /** Size */
+		Stream_Write_UINT16(out, 0);               /* Padding */
+		Stream_Write_UINT32(out, status);          /** UsbdStatus */
+		Stream_Write_UINT32(out, StartFrame);      /** StartFrame */
+
+		if (status == 0)
+		{
+			/** NumberOfPackets */
+			Stream_Write_UINT32(out, NumberOfPackets);
+			Stream_Write_UINT32(out, ErrorCount); /** ErrorCount */
+			Stream_Seek(out, packetSize);
+		}
+		else
+		{
+			Stream_Write_UINT32(out, 0);          /** NumberOfPackets */
+			Stream_Write_UINT32(out, ErrorCount); /** ErrorCount */
+		}
+
+		Stream_Write_UINT32(out, 0);                /** HResult */
+		Stream_Write_UINT32(out, OutputBufferSize); /** OutputBufferSize */
+		Stream_Seek(out, OutputBufferSize);
+
+		stream_write_and_free(callback->plugin, callback->channel, out);
+	}
+}
+
+static UINT urb_isoch_transfer(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback, wStream* s,
+                               UINT32 RequestField, UINT32 MessageId, IUDEVMAN* udevman,
+                               int transferDir)
+{
+	int rc = 0;
+	UINT32 EndpointAddress = 0;
+	UINT32 PipeHandle = 0;
+	UINT32 TransferFlags = 0;
+	UINT32 StartFrame = 0;
+	UINT32 NumberOfPackets = 0;
+	UINT32 ErrorCount = 0;
+	UINT32 OutputBufferSize = 0;
+	BYTE* packetDescriptorData = NULL;
+	const BOOL noAck = (RequestField & 0x80000000U) != 0;
+	const UINT32 RequestId = RequestField & 0x7FFFFFFF;
+
+	if (!pdev || !callback || !udevman)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 20))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT32(s, PipeHandle);
+	EndpointAddress = (PipeHandle & 0x000000ff);
+	Stream_Read_UINT32(s, TransferFlags);   /** TransferFlags */
+	Stream_Read_UINT32(s, StartFrame);      /** StartFrame */
+	Stream_Read_UINT32(s, NumberOfPackets); /** NumberOfPackets */
+	Stream_Read_UINT32(s, ErrorCount);      /** ErrorCount */
+
+	if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, NumberOfPackets, 12ull))
+		return ERROR_INVALID_DATA;
+
+	packetDescriptorData = Stream_Pointer(s);
+	Stream_Seek(s, NumberOfPackets * 12);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, sizeof(UINT32)))
+		return ERROR_INVALID_DATA;
+	Stream_Read_UINT32(s, OutputBufferSize);
+
+	if (transferDir == USBD_TRANSFER_DIRECTION_OUT)
+	{
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, OutputBufferSize))
+			return ERROR_INVALID_DATA;
+	}
+
+	rc = pdev->isoch_transfer(
+	    pdev, callback, MessageId, RequestId, EndpointAddress, TransferFlags, StartFrame,
+	    ErrorCount, noAck, packetDescriptorData, NumberOfPackets, OutputBufferSize,
+	    (transferDir == USBD_TRANSFER_DIRECTION_OUT) ? Stream_Pointer(s) : NULL,
+	    urb_isoch_transfer_cb, 2000);
+
+	if (rc < 0)
+		return ERROR_INTERNAL_ERROR;
+	return (UINT)rc;
+}
+
+static UINT urb_control_descriptor_request(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback,
+                                           wStream* s, UINT32 RequestField, UINT32 MessageId,
+                                           IUDEVMAN* udevman, BYTE func_recipient, int transferDir)
+{
+	size_t out_size = 0;
+	UINT32 InterfaceId = 0;
+	UINT32 OutputBufferSize = 0;
+	UINT32 usbd_status = 0;
+	BYTE bmRequestType = 0;
+	BYTE desc_index = 0;
+	BYTE desc_type = 0;
+	UINT16 langId = 0;
+	wStream* out = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	const BOOL noAck = (RequestField & 0x80000000U) != 0;
+	const UINT32 RequestId = RequestField & 0x7FFFFFFF;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
+		return ERROR_INVALID_DATA;
+
+	InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
+	Stream_Read_UINT8(s, desc_index);
+	Stream_Read_UINT8(s, desc_type);
+	Stream_Read_UINT16(s, langId);
+	Stream_Read_UINT32(s, OutputBufferSize);
+	if (OutputBufferSize > UINT32_MAX - 36)
+		return ERROR_INVALID_DATA;
+	if (transferDir == USBD_TRANSFER_DIRECTION_OUT)
+	{
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, OutputBufferSize))
+			return ERROR_INVALID_DATA;
+	}
+
+	out_size = 36ULL + OutputBufferSize;
+	out = Stream_New(NULL, out_size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Seek(out, 36);
+	bmRequestType = func_recipient;
+
+	switch (transferDir)
+	{
+		case USBD_TRANSFER_DIRECTION_IN:
+			bmRequestType |= 0x80;
+			break;
+
+		case USBD_TRANSFER_DIRECTION_OUT:
+			bmRequestType |= 0x00;
+			Stream_Copy(s, out, OutputBufferSize);
+			Stream_Rewind(out, OutputBufferSize);
+			break;
+
+		default:
+			WLog_Print(urbdrc->log, WLOG_DEBUG, "get error transferDir");
+			OutputBufferSize = 0;
+			usbd_status = USBD_STATUS_STALL_PID;
+			break;
+	}
+
+	/** process get usb device descriptor */
+	if (!pdev->control_transfer(pdev, RequestId, 0, 0, bmRequestType,
+	                            0x06, /* REQUEST_GET_DESCRIPTOR */
+	                            (desc_type << 8) | desc_index, langId, &usbd_status,
+	                            &OutputBufferSize, Stream_Pointer(out), 1000))
+	{
+		WLog_Print(urbdrc->log, WLOG_ERROR, "get_descriptor failed");
+		Stream_Free(out, TRUE);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	return urb_write_completion(pdev, callback, noAck, out, InterfaceId, MessageId, RequestId,
+	                            usbd_status, OutputBufferSize);
+}
+
+static UINT urb_control_get_status_request(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback,
+                                           wStream* s, UINT32 RequestField, UINT32 MessageId,
+                                           IUDEVMAN* udevman, BYTE func_recipient, int transferDir)
+{
+	size_t out_size = 0;
+	UINT32 InterfaceId = 0;
+	UINT32 OutputBufferSize = 0;
+	UINT32 usbd_status = 0;
+	UINT16 Index = 0;
+	BYTE bmRequestType = 0;
+	wStream* out = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	const BOOL noAck = (RequestField & 0x80000000U) != 0;
+	const UINT32 RequestId = RequestField & 0x7FFFFFFF;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (transferDir == 0)
+	{
+		WLog_Print(urbdrc->log, WLOG_DEBUG,
+		           "urb_control_get_status_request: transfer out not supported");
+		return ERROR_INVALID_PARAMETER;
+	}
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
+		return ERROR_INVALID_DATA;
+
+	InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
+	Stream_Read_UINT16(s, Index); /** Index */
+	Stream_Seek(s, 2);
+	Stream_Read_UINT32(s, OutputBufferSize);
+	if (OutputBufferSize > UINT32_MAX - 36)
+		return ERROR_INVALID_DATA;
+	out_size = 36ULL + OutputBufferSize;
+	out = Stream_New(NULL, out_size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Seek(out, 36);
+	bmRequestType = func_recipient | 0x80;
+
+	if (!pdev->control_transfer(pdev, RequestId, 0, 0, bmRequestType, 0x00, /* REQUEST_GET_STATUS */
+	                            0, Index, &usbd_status, &OutputBufferSize, Stream_Pointer(out),
+	                            1000))
+	{
+		WLog_Print(urbdrc->log, WLOG_ERROR, "control_transfer failed");
+		Stream_Free(out, TRUE);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	return urb_write_completion(pdev, callback, noAck, out, InterfaceId, MessageId, RequestId,
+	                            usbd_status, OutputBufferSize);
+}
+
+static UINT urb_control_vendor_or_class_request(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback,
+                                                wStream* s, UINT32 RequestField, UINT32 MessageId,
+                                                IUDEVMAN* udevman, BYTE func_type,
+                                                BYTE func_recipient, int transferDir)
+{
+	UINT32 out_size = 0;
+	UINT32 InterfaceId = 0;
+	UINT32 TransferFlags = 0;
+	UINT32 usbd_status = 0;
+	UINT32 OutputBufferSize = 0;
+	BYTE ReqTypeReservedBits = 0;
+	BYTE Request = 0;
+	BYTE bmRequestType = 0;
+	UINT16 Value = 0;
+	UINT16 Index = 0;
+	UINT16 Padding = 0;
+	wStream* out = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	const BOOL noAck = (RequestField & 0x80000000U) != 0;
+	const UINT32 RequestId = RequestField & 0x7FFFFFFF;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 16))
+		return ERROR_INVALID_DATA;
+
+	InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
+	Stream_Read_UINT32(s, TransferFlags);      /** TransferFlags */
+	Stream_Read_UINT8(s, ReqTypeReservedBits); /** ReqTypeReservedBids */
+	Stream_Read_UINT8(s, Request);             /** Request */
+	Stream_Read_UINT16(s, Value);              /** value */
+	Stream_Read_UINT16(s, Index);              /** index */
+	Stream_Read_UINT16(s, Padding);            /** Padding */
+	Stream_Read_UINT32(s, OutputBufferSize);
+	if (OutputBufferSize > UINT32_MAX - 36)
+		return ERROR_INVALID_DATA;
+
+	if (transferDir == USBD_TRANSFER_DIRECTION_OUT)
+	{
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, OutputBufferSize))
+			return ERROR_INVALID_DATA;
+	}
+
+	out_size = 36ULL + OutputBufferSize;
+	out = Stream_New(NULL, out_size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Seek(out, 36);
+
+	/** Get Buffer */
+	if (transferDir == USBD_TRANSFER_DIRECTION_OUT)
+	{
+		Stream_Copy(s, out, OutputBufferSize);
+		Stream_Rewind(out, OutputBufferSize);
+	}
+
+	/** vendor or class command */
+	bmRequestType = func_type | func_recipient;
+
+	if (TransferFlags & USBD_TRANSFER_DIRECTION)
+		bmRequestType |= 0x80;
+
+	WLog_Print(urbdrc->log, WLOG_DEBUG,
+	           "RequestId 0x%" PRIx32 " TransferFlags: 0x%" PRIx32 " ReqTypeReservedBits: 0x%" PRIx8
+	           " "
+	           "Request:0x%" PRIx8 " Value: 0x%" PRIx16 " Index: 0x%" PRIx16
+	           " OutputBufferSize: 0x%" PRIx32 " bmRequestType: 0x%" PRIx8,
+	           RequestId, TransferFlags, ReqTypeReservedBits, Request, Value, Index,
+	           OutputBufferSize, bmRequestType);
+
+	if (!pdev->control_transfer(pdev, RequestId, 0, 0, bmRequestType, Request, Value, Index,
+	                            &usbd_status, &OutputBufferSize, Stream_Pointer(out), 2000))
+	{
+		WLog_Print(urbdrc->log, WLOG_ERROR, "control_transfer failed");
+		Stream_Free(out, TRUE);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	return urb_write_completion(pdev, callback, noAck, out, InterfaceId, MessageId, RequestId,
+	                            usbd_status, OutputBufferSize);
+}
+
+static UINT urb_os_feature_descriptor_request(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback,
+                                              wStream* s, UINT32 RequestField, UINT32 MessageId,
+                                              IUDEVMAN* udevman, int transferDir)
+{
+	size_t out_size = 0;
+	UINT32 InterfaceId = 0;
+	UINT32 OutputBufferSize = 0;
+	UINT32 usbd_status = 0;
+	BYTE Recipient = 0;
+	BYTE InterfaceNumber = 0;
+	BYTE Ms_PageIndex = 0;
+	UINT16 Ms_featureDescIndex = 0;
+	wStream* out = NULL;
+	int ret = 0;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	const BOOL noAck = (RequestField & 0x80000000U) != 0;
+	const UINT32 RequestId = RequestField & 0x7FFFFFFF;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 12))
+		return ERROR_INVALID_DATA;
+
+	/* 2.2.9.15 TS_URB_OS_FEATURE_DESCRIPTOR_REQUEST */
+	Stream_Read_UINT8(s, Recipient);            /** Recipient */
+	Recipient = (Recipient & 0x1f);             /* Mask out Padding1 */
+	Stream_Read_UINT8(s, InterfaceNumber);      /** InterfaceNumber */
+	Stream_Read_UINT8(s, Ms_PageIndex);         /** Ms_PageIndex */
+	Stream_Read_UINT16(s, Ms_featureDescIndex); /** Ms_featureDescIndex */
+	Stream_Seek(s, 3);                          /* Padding 2 */
+	Stream_Read_UINT32(s, OutputBufferSize);
+	if (OutputBufferSize > UINT32_MAX - 36)
+		return ERROR_INVALID_DATA;
+
+	switch (transferDir)
+	{
+		case USBD_TRANSFER_DIRECTION_OUT:
+			if (!Stream_CheckAndLogRequiredLength(TAG, s, OutputBufferSize))
+				return ERROR_INVALID_DATA;
+
+			break;
+
+		default:
+			break;
+	}
+
+	InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
+	out_size = 36ULL + OutputBufferSize;
+	out = Stream_New(NULL, out_size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Seek(out, 36);
+
+	switch (transferDir)
+	{
+		case USBD_TRANSFER_DIRECTION_OUT:
+			Stream_Copy(s, out, OutputBufferSize);
+			Stream_Rewind(out, OutputBufferSize);
+			break;
+
+		case USBD_TRANSFER_DIRECTION_IN:
+			break;
+	}
+
+	WLog_Print(urbdrc->log, WLOG_DEBUG,
+	           "Ms descriptor arg: Recipient:0x%" PRIx8 ", "
+	           "InterfaceNumber:0x%" PRIx8 ", Ms_PageIndex:0x%" PRIx8 ", "
+	           "Ms_featureDescIndex:0x%" PRIx16 ", OutputBufferSize:0x%" PRIx32 "",
+	           Recipient, InterfaceNumber, Ms_PageIndex, Ms_featureDescIndex, OutputBufferSize);
+	/** get ms string */
+	ret = pdev->os_feature_descriptor_request(pdev, RequestId, Recipient, InterfaceNumber,
+	                                          Ms_PageIndex, Ms_featureDescIndex, &usbd_status,
+	                                          &OutputBufferSize, Stream_Pointer(out), 1000);
+
+	if (ret < 0)
+		WLog_Print(urbdrc->log, WLOG_DEBUG, "os_feature_descriptor_request: error num %d", ret);
+
+	return urb_write_completion(pdev, callback, noAck, out, InterfaceId, MessageId, RequestId,
+	                            usbd_status, OutputBufferSize);
+}
+
+static UINT urb_pipe_request(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback, wStream* s,
+                             UINT32 RequestField, UINT32 MessageId, IUDEVMAN* udevman,
+                             int transferDir, int action)
+{
+	UINT32 out_size = 0;
+	UINT32 InterfaceId = 0;
+	UINT32 PipeHandle = 0;
+	UINT32 EndpointAddress = 0;
+	UINT32 OutputBufferSize = 0;
+	UINT32 usbd_status = 0;
+	wStream* out = NULL;
+	UINT32 ret = USBD_STATUS_REQUEST_FAILED;
+	int rc = 0;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	const BOOL noAck = (RequestField & 0x80000000U) != 0;
+	const UINT32 RequestId = RequestField & 0x7FFFFFFF;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
+		return ERROR_INVALID_DATA;
+
+	if (transferDir == 0)
+	{
+		WLog_Print(urbdrc->log, WLOG_DEBUG, "urb_pipe_request: not support transfer out");
+		return ERROR_INVALID_PARAMETER;
+	}
+
+	InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
+	Stream_Read_UINT32(s, PipeHandle); /** PipeHandle */
+	Stream_Read_UINT32(s, OutputBufferSize);
+	EndpointAddress = (PipeHandle & 0x000000ff);
+
+	switch (action)
+	{
+		case PIPE_CANCEL:
+			rc = pdev->control_pipe_request(pdev, RequestId, EndpointAddress, &usbd_status,
+			                                PIPE_CANCEL);
+
+			if (rc < 0)
+				WLog_Print(urbdrc->log, WLOG_DEBUG, "PIPE SET HALT: error %d", ret);
+			else
+				ret = USBD_STATUS_SUCCESS;
+
+			break;
+
+		case PIPE_RESET:
+			WLog_Print(urbdrc->log, WLOG_DEBUG, "urb_pipe_request: PIPE_RESET ep 0x%" PRIx32 "",
+			           EndpointAddress);
+			rc = pdev->control_pipe_request(pdev, RequestId, EndpointAddress, &usbd_status,
+			                                PIPE_RESET);
+
+			if (rc < 0)
+				WLog_Print(urbdrc->log, WLOG_DEBUG, "PIPE RESET: error %d", ret);
+			else
+				ret = USBD_STATUS_SUCCESS;
+
+			break;
+
+		default:
+			WLog_Print(urbdrc->log, WLOG_DEBUG, "urb_pipe_request action: %d not supported",
+			           action);
+			ret = USBD_STATUS_INVALID_URB_FUNCTION;
+			break;
+	}
+
+	/** send data */
+	out_size = 36;
+	out = Stream_New(NULL, out_size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	return urb_write_completion(pdev, callback, noAck, out, InterfaceId, MessageId, RequestId, ret,
+	                            0);
+}
+
+static UINT urb_get_current_frame_number(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback,
+                                         wStream* s, UINT32 RequestField, UINT32 MessageId,
+                                         IUDEVMAN* udevman, int transferDir)
+{
+	UINT32 out_size = 0;
+	UINT32 InterfaceId = 0;
+	UINT32 OutputBufferSize = 0;
+	UINT32 dummy_frames = 0;
+	wStream* out = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	const BOOL noAck = (RequestField & 0x80000000U) != 0;
+	const UINT32 RequestId = RequestField & 0x7FFFFFFF;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return ERROR_INVALID_DATA;
+
+	if (transferDir == 0)
+	{
+		WLog_Print(urbdrc->log, WLOG_DEBUG,
+		           "urb_get_current_frame_number: not support transfer out");
+		return ERROR_INVALID_PARAMETER;
+	}
+
+	InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
+	Stream_Read_UINT32(s, OutputBufferSize);
+	/** Fixme: Need to fill actual frame number!!*/
+	dummy_frames = GetTickCount();
+	out_size = 40;
+	out = Stream_New(NULL, out_size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Write_UINT32(out, InterfaceId); /** interface */
+	Stream_Write_UINT32(out, MessageId);   /** message id */
+	Stream_Write_UINT32(out, URB_COMPLETION_NO_DATA);
+	Stream_Write_UINT32(out, RequestId); /** RequestId */
+	Stream_Write_UINT32(out, 12);        /** CbTsUrbResult */
+	/** TsUrbResult TS_URB_RESULT_HEADER */
+	Stream_Write_UINT16(out, 12); /** Size */
+	/** Padding, MUST be ignored upon receipt */
+	Stream_Write_UINT16(out, TS_URB_GET_CURRENT_FRAME_NUMBER);
+	Stream_Write_UINT32(out, USBD_STATUS_SUCCESS); /** UsbdStatus */
+	Stream_Write_UINT32(out, dummy_frames);        /** FrameNumber */
+	Stream_Write_UINT32(out, 0);                   /** HResult */
+	Stream_Write_UINT32(out, 0);                   /** OutputBufferSize */
+
+	if (!noAck)
+		return stream_write_and_free(callback->plugin, callback->channel, out);
+	else
+		Stream_Free(out, TRUE);
+
+	return ERROR_SUCCESS;
+}
+
+/* Unused function for current server */
+static UINT urb_control_get_configuration_request(IUDEVICE* pdev,
+                                                  GENERIC_CHANNEL_CALLBACK* callback, wStream* s,
+                                                  UINT32 RequestField, UINT32 MessageId,
+                                                  IUDEVMAN* udevman, int transferDir)
+{
+	size_t out_size = 0;
+	UINT32 InterfaceId = 0;
+	UINT32 OutputBufferSize = 0;
+	UINT32 usbd_status = 0;
+	wStream* out = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	const BOOL noAck = (RequestField & 0x80000000U) != 0;
+	const UINT32 RequestId = RequestField & 0x7FFFFFFF;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (transferDir == 0)
+	{
+		WLog_Print(urbdrc->log, WLOG_DEBUG,
+		           "urb_control_get_configuration_request:"
+		           " not support transfer out");
+		return ERROR_INVALID_PARAMETER;
+	}
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT32(s, OutputBufferSize);
+	if (OutputBufferSize > UINT32_MAX - 36)
+		return ERROR_INVALID_DATA;
+	out_size = 36ULL + OutputBufferSize;
+	out = Stream_New(NULL, out_size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Seek(out, 36);
+	InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
+
+	if (!pdev->control_transfer(pdev, RequestId, 0, 0, 0x80 | 0x00,
+	                            0x08, /* REQUEST_GET_CONFIGURATION */
+	                            0, 0, &usbd_status, &OutputBufferSize, Stream_Pointer(out), 1000))
+	{
+		WLog_Print(urbdrc->log, WLOG_DEBUG, "control_transfer failed");
+		Stream_Free(out, TRUE);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	return urb_write_completion(pdev, callback, noAck, out, InterfaceId, MessageId, RequestId,
+	                            usbd_status, OutputBufferSize);
+}
+
+/* Unused function for current server */
+static UINT urb_control_get_interface_request(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback,
+                                              wStream* s, UINT32 RequestField, UINT32 MessageId,
+                                              IUDEVMAN* udevman, int transferDir)
+{
+	size_t out_size = 0;
+	UINT32 InterfaceId = 0;
+	UINT32 OutputBufferSize = 0;
+	UINT32 usbd_status = 0;
+	UINT16 InterfaceNr = 0;
+	wStream* out = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	const BOOL noAck = (RequestField & 0x80000000U) != 0;
+	const UINT32 RequestId = RequestField & 0x7FFFFFFF;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
+		return ERROR_INVALID_DATA;
+
+	if (transferDir == 0)
+	{
+		WLog_Print(urbdrc->log, WLOG_DEBUG,
+		           "urb_control_get_interface_request: not support transfer out");
+		return ERROR_INVALID_PARAMETER;
+	}
+
+	InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
+	Stream_Read_UINT16(s, InterfaceNr);
+	Stream_Seek(s, 2);
+	Stream_Read_UINT32(s, OutputBufferSize);
+	if (OutputBufferSize > UINT32_MAX - 36)
+		return ERROR_INVALID_DATA;
+	out_size = 36ULL + OutputBufferSize;
+	out = Stream_New(NULL, out_size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Seek(out, 36);
+
+	if (!pdev->control_transfer(
+	        pdev, RequestId, 0, 0, 0x80 | 0x01, 0x0A, /* REQUEST_GET_INTERFACE */
+	        0, InterfaceNr, &usbd_status, &OutputBufferSize, Stream_Pointer(out), 1000))
+	{
+		WLog_Print(urbdrc->log, WLOG_DEBUG, "control_transfer failed");
+		Stream_Free(out, TRUE);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	return urb_write_completion(pdev, callback, noAck, out, InterfaceId, MessageId, RequestId,
+	                            usbd_status, OutputBufferSize);
+}
+
+static UINT urb_control_feature_request(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback,
+                                        wStream* s, UINT32 RequestField, UINT32 MessageId,
+                                        IUDEVMAN* udevman, BYTE func_recipient, BYTE command,
+                                        int transferDir)
+{
+	UINT32 InterfaceId = 0;
+	UINT32 OutputBufferSize = 0;
+	UINT32 usbd_status = 0;
+	UINT16 FeatureSelector = 0;
+	UINT16 Index = 0;
+	BYTE bmRequestType = 0;
+	BYTE bmRequest = 0;
+	wStream* out = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	const BOOL noAck = (RequestField & 0x80000000U) != 0;
+	const UINT32 RequestId = RequestField & 0x7FFFFFFF;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
+		return ERROR_INVALID_DATA;
+
+	InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
+	Stream_Read_UINT16(s, FeatureSelector);
+	Stream_Read_UINT16(s, Index);
+	Stream_Read_UINT32(s, OutputBufferSize);
+	if (OutputBufferSize > UINT32_MAX - 36)
+		return ERROR_INVALID_DATA;
+	switch (transferDir)
+	{
+		case USBD_TRANSFER_DIRECTION_OUT:
+			if (!Stream_CheckAndLogRequiredLength(TAG, s, OutputBufferSize))
+				return ERROR_INVALID_DATA;
+
+			break;
+
+		default:
+			break;
+	}
+
+	out = Stream_New(NULL, 36ULL + OutputBufferSize);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Seek(out, 36);
+	bmRequestType = func_recipient;
+
+	switch (transferDir)
+	{
+		case USBD_TRANSFER_DIRECTION_OUT:
+			WLog_Print(urbdrc->log, WLOG_ERROR,
+			           "Function urb_control_feature_request: OUT Unchecked");
+			Stream_Copy(s, out, OutputBufferSize);
+			Stream_Rewind(out, OutputBufferSize);
+			bmRequestType |= 0x00;
+			break;
+
+		case USBD_TRANSFER_DIRECTION_IN:
+			bmRequestType |= 0x80;
+			break;
+	}
+
+	switch (command)
+	{
+		case URB_SET_FEATURE:
+			bmRequest = 0x03; /* REQUEST_SET_FEATURE */
+			break;
+
+		case URB_CLEAR_FEATURE:
+			bmRequest = 0x01; /* REQUEST_CLEAR_FEATURE */
+			break;
+
+		default:
+			WLog_Print(urbdrc->log, WLOG_ERROR,
+			           "urb_control_feature_request: Error Command 0x%02" PRIx8 "", command);
+			Stream_Free(out, TRUE);
+			return ERROR_INTERNAL_ERROR;
+	}
+
+	if (!pdev->control_transfer(pdev, RequestId, 0, 0, bmRequestType, bmRequest, FeatureSelector,
+	                            Index, &usbd_status, &OutputBufferSize, Stream_Pointer(out), 1000))
+	{
+		WLog_Print(urbdrc->log, WLOG_DEBUG, "feature control transfer failed");
+		Stream_Free(out, TRUE);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	return urb_write_completion(pdev, callback, noAck, out, InterfaceId, MessageId, RequestId,
+	                            usbd_status, OutputBufferSize);
+}
+
+static UINT urbdrc_process_transfer_request(IUDEVICE* pdev, GENERIC_CHANNEL_CALLBACK* callback,
+                                            wStream* s, UINT32 MessageId, IUDEVMAN* udevman,
+                                            int transferDir)
+{
+	UINT32 CbTsUrb = 0;
+	UINT16 Size = 0;
+	UINT16 URB_Function = 0;
+	UINT32 RequestId = 0;
+	UINT error = ERROR_INTERNAL_ERROR;
+	URBDRC_PLUGIN* urbdrc = NULL;
+
+	if (!callback || !s || !udevman || !pdev)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 12))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT32(s, CbTsUrb); /** CbTsUrb */
+	Stream_Read_UINT16(s, Size);    /** size */
+	Stream_Read_UINT16(s, URB_Function);
+	Stream_Read_UINT32(s, RequestId);
+	WLog_Print(urbdrc->log, WLOG_DEBUG, "URB %s[%" PRIu16 "]", urb_function_string(URB_Function),
+	           URB_Function);
+
+	switch (URB_Function)
+	{
+		case TS_URB_SELECT_CONFIGURATION: /** 0x0000 */
+			error = urb_select_configuration(pdev, callback, s, RequestId, MessageId, udevman,
+			                                 transferDir);
+			break;
+
+		case TS_URB_SELECT_INTERFACE: /** 0x0001 */
+			error =
+			    urb_select_interface(pdev, callback, s, RequestId, MessageId, udevman, transferDir);
+			break;
+
+		case TS_URB_PIPE_REQUEST: /** 0x0002  */
+			error = urb_pipe_request(pdev, callback, s, RequestId, MessageId, udevman, transferDir,
+			                         PIPE_CANCEL);
+			break;
+
+		case TS_URB_TAKE_FRAME_LENGTH_CONTROL: /** 0x0003  */
+			/** This URB function is obsolete in Windows 2000
+			 * and later operating systems
+			 * and is not supported by Microsoft. */
+			break;
+
+		case TS_URB_RELEASE_FRAME_LENGTH_CONTROL: /** 0x0004 */
+			/** This URB function is obsolete in Windows 2000
+			 * and later operating systems
+			 * and is not supported by Microsoft. */
+			break;
+
+		case TS_URB_GET_FRAME_LENGTH: /** 0x0005 */
+			/** This URB function is obsolete in Windows 2000
+			 * and later operating systems
+			 * and is not supported by Microsoft. */
+			break;
+
+		case TS_URB_SET_FRAME_LENGTH: /** 0x0006 */
+			/** This URB function is obsolete in Windows 2000
+			 * and later operating systems
+			 * and is not supported by Microsoft. */
+			break;
+
+		case TS_URB_GET_CURRENT_FRAME_NUMBER: /** 0x0007 */
+			error = urb_get_current_frame_number(pdev, callback, s, RequestId, MessageId, udevman,
+			                                     transferDir);
+			break;
+
+		case TS_URB_CONTROL_TRANSFER: /** 0x0008 */
+			error = urb_control_transfer(pdev, callback, s, RequestId, MessageId, udevman,
+			                             transferDir, URB_CONTROL_TRANSFER_NONEXTERNAL);
+			break;
+
+		case TS_URB_BULK_OR_INTERRUPT_TRANSFER: /** 0x0009 */
+			error = urb_bulk_or_interrupt_transfer(pdev, callback, s, RequestId, MessageId, udevman,
+			                                       transferDir);
+			break;
+
+		case TS_URB_ISOCH_TRANSFER: /** 0x000A */
+			error =
+			    urb_isoch_transfer(pdev, callback, s, RequestId, MessageId, udevman, transferDir);
+			break;
+
+		case TS_URB_GET_DESCRIPTOR_FROM_DEVICE: /** 0x000B */
+			error = urb_control_descriptor_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                       0x00, transferDir);
+			break;
+
+		case TS_URB_SET_DESCRIPTOR_TO_DEVICE: /** 0x000C */
+			error = urb_control_descriptor_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                       0x00, transferDir);
+			break;
+
+		case TS_URB_SET_FEATURE_TO_DEVICE: /** 0x000D */
+			error = urb_control_feature_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                    0x00, URB_SET_FEATURE, transferDir);
+			break;
+
+		case TS_URB_SET_FEATURE_TO_INTERFACE: /** 0x000E */
+			error = urb_control_feature_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                    0x01, URB_SET_FEATURE, transferDir);
+			break;
+
+		case TS_URB_SET_FEATURE_TO_ENDPOINT: /** 0x000F */
+			error = urb_control_feature_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                    0x02, URB_SET_FEATURE, transferDir);
+			break;
+
+		case TS_URB_CLEAR_FEATURE_TO_DEVICE: /** 0x0010 */
+			error = urb_control_feature_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                    0x00, URB_CLEAR_FEATURE, transferDir);
+			break;
+
+		case TS_URB_CLEAR_FEATURE_TO_INTERFACE: /** 0x0011 */
+			error = urb_control_feature_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                    0x01, URB_CLEAR_FEATURE, transferDir);
+			break;
+
+		case TS_URB_CLEAR_FEATURE_TO_ENDPOINT: /** 0x0012 */
+			error = urb_control_feature_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                    0x02, URB_CLEAR_FEATURE, transferDir);
+			break;
+
+		case TS_URB_GET_STATUS_FROM_DEVICE: /** 0x0013 */
+			error = urb_control_get_status_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                       0x00, transferDir);
+			break;
+
+		case TS_URB_GET_STATUS_FROM_INTERFACE: /** 0x0014 */
+			error = urb_control_get_status_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                       0x01, transferDir);
+			break;
+
+		case TS_URB_GET_STATUS_FROM_ENDPOINT: /** 0x0015 */
+			error = urb_control_get_status_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                       0x02, transferDir);
+			break;
+
+		case TS_URB_RESERVED_0X0016: /** 0x0016 */
+			break;
+
+		case TS_URB_VENDOR_DEVICE: /** 0x0017 */
+			error = urb_control_vendor_or_class_request(pdev, callback, s, RequestId, MessageId,
+			                                            udevman, (0x02 << 5), /* vendor type */
+			                                            0x00, transferDir);
+			break;
+
+		case TS_URB_VENDOR_INTERFACE: /** 0x0018 */
+			error = urb_control_vendor_or_class_request(pdev, callback, s, RequestId, MessageId,
+			                                            udevman, (0x02 << 5), /* vendor type */
+			                                            0x01, transferDir);
+			break;
+
+		case TS_URB_VENDOR_ENDPOINT: /** 0x0019 */
+			error = urb_control_vendor_or_class_request(pdev, callback, s, RequestId, MessageId,
+			                                            udevman, (0x02 << 5), /* vendor type */
+			                                            0x02, transferDir);
+			break;
+
+		case TS_URB_CLASS_DEVICE: /** 0x001A */
+			error = urb_control_vendor_or_class_request(pdev, callback, s, RequestId, MessageId,
+			                                            udevman, (0x01 << 5), /* class type */
+			                                            0x00, transferDir);
+			break;
+
+		case TS_URB_CLASS_INTERFACE: /** 0x001B */
+			error = urb_control_vendor_or_class_request(pdev, callback, s, RequestId, MessageId,
+			                                            udevman, (0x01 << 5), /* class type */
+			                                            0x01, transferDir);
+			break;
+
+		case TS_URB_CLASS_ENDPOINT: /** 0x001C */
+			error = urb_control_vendor_or_class_request(pdev, callback, s, RequestId, MessageId,
+			                                            udevman, (0x01 << 5), /* class type */
+			                                            0x02, transferDir);
+			break;
+
+		case TS_URB_RESERVE_0X001D: /** 0x001D */
+			break;
+
+		case TS_URB_SYNC_RESET_PIPE_AND_CLEAR_STALL: /** 0x001E */
+			error = urb_pipe_request(pdev, callback, s, RequestId, MessageId, udevman, transferDir,
+			                         PIPE_RESET);
+			break;
+
+		case TS_URB_CLASS_OTHER: /** 0x001F */
+			error = urb_control_vendor_or_class_request(pdev, callback, s, RequestId, MessageId,
+			                                            udevman, (0x01 << 5), /* class type */
+			                                            0x03, transferDir);
+			break;
+
+		case TS_URB_VENDOR_OTHER: /** 0x0020 */
+			error = urb_control_vendor_or_class_request(pdev, callback, s, RequestId, MessageId,
+			                                            udevman, (0x02 << 5), /* vendor type */
+			                                            0x03, transferDir);
+			break;
+
+		case TS_URB_GET_STATUS_FROM_OTHER: /** 0x0021 */
+			error = urb_control_get_status_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                       0x03, transferDir);
+			break;
+
+		case TS_URB_CLEAR_FEATURE_TO_OTHER: /** 0x0022 */
+			error = urb_control_feature_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                    0x03, URB_CLEAR_FEATURE, transferDir);
+			break;
+
+		case TS_URB_SET_FEATURE_TO_OTHER: /** 0x0023 */
+			error = urb_control_feature_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                    0x03, URB_SET_FEATURE, transferDir);
+			break;
+
+		case TS_URB_GET_DESCRIPTOR_FROM_ENDPOINT: /** 0x0024 */
+			error = urb_control_descriptor_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                       0x02, transferDir);
+			break;
+
+		case TS_URB_SET_DESCRIPTOR_TO_ENDPOINT: /** 0x0025 */
+			error = urb_control_descriptor_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                       0x02, transferDir);
+			break;
+
+		case TS_URB_CONTROL_GET_CONFIGURATION_REQUEST: /** 0x0026 */
+			error = urb_control_get_configuration_request(pdev, callback, s, RequestId, MessageId,
+			                                              udevman, transferDir);
+			break;
+
+		case TS_URB_CONTROL_GET_INTERFACE_REQUEST: /** 0x0027 */
+			error = urb_control_get_interface_request(pdev, callback, s, RequestId, MessageId,
+			                                          udevman, transferDir);
+			break;
+
+		case TS_URB_GET_DESCRIPTOR_FROM_INTERFACE: /** 0x0028 */
+			error = urb_control_descriptor_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                       0x01, transferDir);
+			break;
+
+		case TS_URB_SET_DESCRIPTOR_TO_INTERFACE: /** 0x0029 */
+			error = urb_control_descriptor_request(pdev, callback, s, RequestId, MessageId, udevman,
+			                                       0x01, transferDir);
+			break;
+
+		case TS_URB_GET_OS_FEATURE_DESCRIPTOR_REQUEST: /** 0x002A */
+			error = urb_os_feature_descriptor_request(pdev, callback, s, RequestId, MessageId,
+			                                          udevman, transferDir);
+			break;
+
+		case TS_URB_RESERVE_0X002B: /** 0x002B */
+		case TS_URB_RESERVE_0X002C: /** 0x002C */
+		case TS_URB_RESERVE_0X002D: /** 0x002D */
+		case TS_URB_RESERVE_0X002E: /** 0x002E */
+		case TS_URB_RESERVE_0X002F: /** 0x002F */
+			break;
+
+		/** USB 2.0 calls start at 0x0030 */
+		case TS_URB_SYNC_RESET_PIPE: /** 0x0030 */
+			error = urb_pipe_request(pdev, callback, s, RequestId, MessageId, udevman, transferDir,
+			                         PIPE_RESET);
+			break;
+
+		case TS_URB_SYNC_CLEAR_STALL: /** 0x0031 */
+			urb_pipe_request(pdev, callback, s, RequestId, MessageId, udevman, transferDir,
+			                 PIPE_RESET);
+			break;
+
+		case TS_URB_CONTROL_TRANSFER_EX: /** 0x0032 */
+			error = urb_control_transfer(pdev, callback, s, RequestId, MessageId, udevman,
+			                             transferDir, URB_CONTROL_TRANSFER_EXTERNAL);
+			break;
+
+		default:
+			WLog_Print(urbdrc->log, WLOG_DEBUG, "URB_Func: %" PRIx16 " is not found!",
+			           URB_Function);
+			break;
+	}
+
+	if (error)
+	{
+		WLog_Print(urbdrc->log, WLOG_WARN,
+		           "USB transfer request URB Function '%s' [0x%08x] failed with %08" PRIx32,
+		           urb_function_string(URB_Function), URB_Function, error);
+	}
+
+	return error;
+}
+
+UINT urbdrc_process_udev_data_transfer(GENERIC_CHANNEL_CALLBACK* callback, URBDRC_PLUGIN* urbdrc,
+                                       IUDEVMAN* udevman, wStream* data)
+{
+	UINT32 InterfaceId = 0;
+	UINT32 MessageId = 0;
+	UINT32 FunctionId = 0;
+	IUDEVICE* pdev = NULL;
+	UINT error = ERROR_INTERNAL_ERROR;
+
+	if (!urbdrc || !data || !callback || !udevman)
+		goto fail;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, data, 8))
+		goto fail;
+
+	Stream_Rewind_UINT32(data);
+
+	Stream_Read_UINT32(data, InterfaceId);
+	Stream_Read_UINT32(data, MessageId);
+	Stream_Read_UINT32(data, FunctionId);
+
+	pdev = udevman->get_udevice_by_UsbDevice(udevman, InterfaceId);
+
+	/* Device does not exist, ignore this request. */
+	if (pdev == NULL)
+	{
+		error = ERROR_SUCCESS;
+		goto fail;
+	}
+
+	/* Device has been removed, ignore this request. */
+	if (pdev->isChannelClosed(pdev))
+	{
+		error = ERROR_SUCCESS;
+		goto fail;
+	}
+
+	/* USB kernel driver detach!! */
+	pdev->detach_kernel_driver(pdev);
+
+	switch (FunctionId)
+	{
+		case CANCEL_REQUEST:
+			error = urbdrc_process_cancel_request(pdev, data, udevman);
+			break;
+
+		case REGISTER_REQUEST_CALLBACK:
+			error = urbdrc_process_register_request_callback(pdev, callback, data, udevman);
+			break;
+
+		case IO_CONTROL:
+			error = urbdrc_process_io_control(pdev, callback, data, MessageId, udevman);
+			break;
+
+		case INTERNAL_IO_CONTROL:
+			error = urbdrc_process_internal_io_control(pdev, callback, data, MessageId, udevman);
+			break;
+
+		case QUERY_DEVICE_TEXT:
+			error = urbdrc_process_query_device_text(pdev, callback, data, MessageId, udevman);
+			break;
+
+		case TRANSFER_IN_REQUEST:
+			error = urbdrc_process_transfer_request(pdev, callback, data, MessageId, udevman,
+			                                        USBD_TRANSFER_DIRECTION_IN);
+			break;
+
+		case TRANSFER_OUT_REQUEST:
+			error = urbdrc_process_transfer_request(pdev, callback, data, MessageId, udevman,
+			                                        USBD_TRANSFER_DIRECTION_OUT);
+			break;
+
+		case RETRACT_DEVICE:
+			error = urbdrc_process_retract_device_request(pdev, data, udevman);
+			break;
+
+		default:
+			WLog_Print(urbdrc->log, WLOG_WARN,
+			           "urbdrc_process_udev_data_transfer:"
+			           " unknown FunctionId 0x%" PRIX32 "",
+			           FunctionId);
+			break;
+	}
+
+fail:
+	if (error)
+	{
+		WLog_WARN(TAG, "USB request failed with %08" PRIx32, error);
+	}
+
+	return error;
+}
diff --git a/channels/urbdrc/client/data_transfer.h b/channels/urbdrc/client/data_transfer.h
new file mode 100644
index 0000000..1d7126d
--- /dev/null
+++ b/channels/urbdrc/client/data_transfer.h
@@ -0,0 +1,36 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX USB Redirection
+ *
+ * Copyright 2012 Atrust corp.
+ * Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_CHANNEL_URBDRC_CLIENT_DATA_TRANSFER_H
+#define FREERDP_CHANNEL_URBDRC_CLIENT_DATA_TRANSFER_H
+
+#include <winpr/pool.h>
+
+#include "urbdrc_main.h"
+
+#define DEVICE_CTX(dev) ((dev)->ctx)
+#define HANDLE_CTX(handle) (DEVICE_CTX((handle)->dev))
+#define TRANSFER_CTX(transfer) (HANDLE_CTX((transfer)->dev_handle))
+#define ITRANSFER_CTX(transfer) (TRANSFER_CTX(__USBI_TRANSFER_TO_LIBUSB_TRANSFER(transfer)))
+
+UINT urbdrc_process_udev_data_transfer(GENERIC_CHANNEL_CALLBACK* callback, URBDRC_PLUGIN* urbdrc,
+                                       IUDEVMAN* udevman, wStream* data);
+
+#endif /* FREERDP_CHANNEL_URBDRC_CLIENT_DATA_TRANSFER_H */
diff --git a/channels/urbdrc/client/libusb/CMakeLists.txt b/channels/urbdrc/client/libusb/CMakeLists.txt
new file mode 100644
index 0000000..4e219de
--- /dev/null
+++ b/channels/urbdrc/client/libusb/CMakeLists.txt
@@ -0,0 +1,36 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP cmake build script
+#
+# Copyright 2012 Atrust corp.
+# Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+define_channel_client_subsystem("urbdrc" "libusb" "")
+
+set(${MODULE_PREFIX}_SRCS
+	libusb_udevman.c
+	libusb_udevice.c
+	libusb_udevice.h
+)
+
+set(${MODULE_PREFIX}_LIBS
+	${CMAKE_THREAD_LIBS_INIT}
+	${LIBUSB_1_LIBRARIES}
+    winpr freerdp
+)
+
+include_directories(..)
+
+add_channel_client_subsystem_library(${MODULE_PREFIX} ${MODULE_NAME} ${CHANNEL_NAME} "" TRUE "")
+
diff --git a/channels/urbdrc/client/libusb/libusb_udevice.c b/channels/urbdrc/client/libusb/libusb_udevice.c
new file mode 100644
index 0000000..c226eb8
--- /dev/null
+++ b/channels/urbdrc/client/libusb/libusb_udevice.c
@@ -0,0 +1,1841 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX USB Redirection
+ *
+ * Copyright 2012 Atrust corp.
+ * Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <winpr/wtypes.h>
+#include <winpr/sysinfo.h>
+#include <winpr/collections.h>
+
+#include <errno.h>
+
+#include "libusb_udevice.h"
+#include "../common/urbdrc_types.h"
+
+#define BASIC_STATE_FUNC_DEFINED(_arg, _type)             \
+	static _type udev_get_##_arg(IUDEVICE* idev)          \
+	{                                                     \
+		UDEVICE* pdev = (UDEVICE*)idev;                   \
+		return pdev->_arg;                                \
+	}                                                     \
+	static void udev_set_##_arg(IUDEVICE* idev, _type _t) \
+	{                                                     \
+		UDEVICE* pdev = (UDEVICE*)idev;                   \
+		pdev->_arg = _t;                                  \
+	}
+
+#define BASIC_POINT_FUNC_DEFINED(_arg, _type)               \
+	static _type udev_get_p_##_arg(IUDEVICE* idev)          \
+	{                                                       \
+		UDEVICE* pdev = (UDEVICE*)idev;                     \
+		return pdev->_arg;                                  \
+	}                                                       \
+	static void udev_set_p_##_arg(IUDEVICE* idev, _type _t) \
+	{                                                       \
+		UDEVICE* pdev = (UDEVICE*)idev;                     \
+		pdev->_arg = _t;                                    \
+	}
+
+#define BASIC_STATE_FUNC_REGISTER(_arg, _dev) \
+	_dev->iface.get_##_arg = udev_get_##_arg; \
+	_dev->iface.set_##_arg = udev_set_##_arg
+
+#if LIBUSB_API_VERSION >= 0x01000103
+#define HAVE_STREAM_ID_API 1
+#endif
+
+typedef struct
+{
+	wStream* data;
+	BOOL noack;
+	UINT32 MessageId;
+	UINT32 StartFrame;
+	UINT32 ErrorCount;
+	IUDEVICE* idev;
+	UINT32 OutputBufferSize;
+	GENERIC_CHANNEL_CALLBACK* callback;
+	t_isoch_transfer_cb cb;
+	wArrayList* queue;
+#if !defined(HAVE_STREAM_ID_API)
+	UINT32 streamID;
+#endif
+} ASYNC_TRANSFER_USER_DATA;
+
+static void request_free(void* value);
+
+static struct libusb_transfer* list_contains(wArrayList* list, UINT32 streamID)
+{
+	size_t count = 0;
+	if (!list)
+		return NULL;
+	count = ArrayList_Count(list);
+	for (size_t x = 0; x < count; x++)
+	{
+		struct libusb_transfer* transfer = ArrayList_GetItem(list, x);
+
+#if defined(HAVE_STREAM_ID_API)
+		const UINT32 currentID = libusb_transfer_get_stream_id(transfer);
+#else
+		const ASYNC_TRANSFER_USER_DATA* user_data = (ASYNC_TRANSFER_USER_DATA*)transfer->user_data;
+		const UINT32 currentID = user_data->streamID;
+#endif
+		if (currentID == streamID)
+			return transfer;
+	}
+	return NULL;
+}
+
+static UINT32 stream_id_from_buffer(struct libusb_transfer* transfer)
+{
+	if (!transfer)
+		return 0;
+#if defined(HAVE_STREAM_ID_API)
+	return libusb_transfer_get_stream_id(transfer);
+#else
+	ASYNC_TRANSFER_USER_DATA* user_data = (ASYNC_TRANSFER_USER_DATA*)transfer->user_data;
+	if (!user_data)
+		return 0;
+	return user_data->streamID;
+#endif
+}
+
+static void set_stream_id_for_buffer(struct libusb_transfer* transfer, UINT32 streamID)
+{
+#if defined(HAVE_STREAM_ID_API)
+	libusb_transfer_set_stream_id(transfer, streamID);
+#else
+	ASYNC_TRANSFER_USER_DATA* user_data = (ASYNC_TRANSFER_USER_DATA*)transfer->user_data;
+	if (!user_data)
+		return;
+	user_data->streamID = streamID;
+#endif
+}
+
+WINPR_ATTR_FORMAT_ARG(3, 8)
+static BOOL log_libusb_result_(wLog* log, DWORD lvl, WINPR_FORMAT_ARG const char* fmt,
+                               const char* fkt, const char* file, size_t line, int error, ...)
+{
+	WINPR_UNUSED(file);
+
+	if (error < 0)
+	{
+		char buffer[8192] = { 0 };
+		va_list ap;
+		va_start(ap, error);
+		vsnprintf(buffer, sizeof(buffer), fmt, ap);
+		va_end(ap);
+
+		WLog_Print(log, lvl, "[%s:%" PRIuz "]: %s: error %s[%d]", fkt, line, buffer,
+		           libusb_error_name(error), error);
+		return TRUE;
+	}
+	return FALSE;
+}
+
+#define log_libusb_result(log, lvl, fmt, error, ...) \
+	log_libusb_result_((log), (lvl), (fmt), __func__, __FILE__, __LINE__, error, ##__VA_ARGS__)
+
+const char* usb_interface_class_to_string(uint8_t class)
+{
+	switch (class)
+	{
+		case LIBUSB_CLASS_PER_INTERFACE:
+			return "LIBUSB_CLASS_PER_INTERFACE";
+		case LIBUSB_CLASS_AUDIO:
+			return "LIBUSB_CLASS_AUDIO";
+		case LIBUSB_CLASS_COMM:
+			return "LIBUSB_CLASS_COMM";
+		case LIBUSB_CLASS_HID:
+			return "LIBUSB_CLASS_HID";
+		case LIBUSB_CLASS_PHYSICAL:
+			return "LIBUSB_CLASS_PHYSICAL";
+		case LIBUSB_CLASS_PRINTER:
+			return "LIBUSB_CLASS_PRINTER";
+		case LIBUSB_CLASS_IMAGE:
+			return "LIBUSB_CLASS_IMAGE";
+		case LIBUSB_CLASS_MASS_STORAGE:
+			return "LIBUSB_CLASS_MASS_STORAGE";
+		case LIBUSB_CLASS_HUB:
+			return "LIBUSB_CLASS_HUB";
+		case LIBUSB_CLASS_DATA:
+			return "LIBUSB_CLASS_DATA";
+		case LIBUSB_CLASS_SMART_CARD:
+			return "LIBUSB_CLASS_SMART_CARD";
+		case LIBUSB_CLASS_CONTENT_SECURITY:
+			return "LIBUSB_CLASS_CONTENT_SECURITY";
+		case LIBUSB_CLASS_VIDEO:
+			return "LIBUSB_CLASS_VIDEO";
+		case LIBUSB_CLASS_PERSONAL_HEALTHCARE:
+			return "LIBUSB_CLASS_PERSONAL_HEALTHCARE";
+		case LIBUSB_CLASS_DIAGNOSTIC_DEVICE:
+			return "LIBUSB_CLASS_DIAGNOSTIC_DEVICE";
+		case LIBUSB_CLASS_WIRELESS:
+			return "LIBUSB_CLASS_WIRELESS";
+		case LIBUSB_CLASS_APPLICATION:
+			return "LIBUSB_CLASS_APPLICATION";
+		case LIBUSB_CLASS_VENDOR_SPEC:
+			return "LIBUSB_CLASS_VENDOR_SPEC";
+		default:
+			return "UNKNOWN_DEVICE_CLASS";
+	}
+}
+
+static ASYNC_TRANSFER_USER_DATA* async_transfer_user_data_new(IUDEVICE* idev, UINT32 MessageId,
+                                                              size_t offset, size_t BufferSize,
+                                                              const BYTE* data, size_t packetSize,
+                                                              BOOL NoAck, t_isoch_transfer_cb cb,
+                                                              GENERIC_CHANNEL_CALLBACK* callback)
+{
+	ASYNC_TRANSFER_USER_DATA* user_data = NULL;
+	UDEVICE* pdev = (UDEVICE*)idev;
+
+	if (BufferSize > UINT32_MAX)
+		return NULL;
+
+	user_data = calloc(1, sizeof(ASYNC_TRANSFER_USER_DATA));
+	if (!user_data)
+		return NULL;
+
+	user_data->data = Stream_New(NULL, offset + BufferSize + packetSize);
+
+	if (!user_data->data)
+	{
+		free(user_data);
+		return NULL;
+	}
+
+	Stream_Seek(user_data->data, offset); /* Skip header offset */
+	if (data)
+		memcpy(Stream_Pointer(user_data->data), data, BufferSize);
+	else
+		user_data->OutputBufferSize = (UINT32)BufferSize;
+
+	user_data->noack = NoAck;
+	user_data->cb = cb;
+	user_data->callback = callback;
+	user_data->idev = idev;
+	user_data->MessageId = MessageId;
+
+	user_data->queue = pdev->request_queue;
+
+	return user_data;
+}
+
+static void async_transfer_user_data_free(ASYNC_TRANSFER_USER_DATA* user_data)
+{
+	if (user_data)
+	{
+		Stream_Free(user_data->data, TRUE);
+		free(user_data);
+	}
+}
+
+static void LIBUSB_CALL func_iso_callback(struct libusb_transfer* transfer)
+{
+	ASYNC_TRANSFER_USER_DATA* user_data = (ASYNC_TRANSFER_USER_DATA*)transfer->user_data;
+	const UINT32 streamID = stream_id_from_buffer(transfer);
+	wArrayList* list = user_data->queue;
+
+	ArrayList_Lock(list);
+	switch (transfer->status)
+	{
+		case LIBUSB_TRANSFER_COMPLETED:
+		{
+			UINT32 index = 0;
+			BYTE* dataStart = Stream_Pointer(user_data->data);
+			Stream_SetPosition(user_data->data,
+			                   40); /* TS_URB_ISOCH_TRANSFER_RESULT IsoPacket offset */
+
+			for (int i = 0; i < transfer->num_iso_packets; i++)
+			{
+				const UINT32 act_len = transfer->iso_packet_desc[i].actual_length;
+				Stream_Write_UINT32(user_data->data, index);
+				Stream_Write_UINT32(user_data->data, act_len);
+				Stream_Write_UINT32(user_data->data, transfer->iso_packet_desc[i].status);
+
+				if (transfer->iso_packet_desc[i].status != USBD_STATUS_SUCCESS)
+					user_data->ErrorCount++;
+				else
+				{
+					const unsigned char* packetBuffer =
+					    libusb_get_iso_packet_buffer_simple(transfer, i);
+					BYTE* data = dataStart + index;
+
+					if (data != packetBuffer)
+						memmove(data, packetBuffer, act_len);
+
+					index += act_len;
+				}
+			}
+		}
+			/* fallthrough */
+			WINPR_FALLTHROUGH
+		case LIBUSB_TRANSFER_CANCELLED:
+			/* fallthrough */
+			WINPR_FALLTHROUGH
+		case LIBUSB_TRANSFER_TIMED_OUT:
+			/* fallthrough */
+			WINPR_FALLTHROUGH
+		case LIBUSB_TRANSFER_ERROR:
+		{
+			const UINT32 InterfaceId =
+			    ((STREAM_ID_PROXY << 30) | user_data->idev->get_ReqCompletion(user_data->idev));
+
+			if (list_contains(list, streamID))
+			{
+				if (!user_data->noack)
+				{
+					const UINT32 RequestID = streamID & INTERFACE_ID_MASK;
+					user_data->cb(user_data->idev, user_data->callback, user_data->data,
+					              InterfaceId, user_data->noack, user_data->MessageId, RequestID,
+					              transfer->num_iso_packets, transfer->status,
+					              user_data->StartFrame, user_data->ErrorCount,
+					              user_data->OutputBufferSize);
+					user_data->data = NULL;
+				}
+				ArrayList_Remove(list, transfer);
+			}
+		}
+		break;
+		default:
+			break;
+	}
+	ArrayList_Unlock(list);
+}
+
+static const LIBUSB_ENDPOINT_DESCEIPTOR* func_get_ep_desc(LIBUSB_CONFIG_DESCRIPTOR* LibusbConfig,
+                                                          MSUSB_CONFIG_DESCRIPTOR* MsConfig,
+                                                          UINT32 EndpointAddress)
+{
+	MSUSB_INTERFACE_DESCRIPTOR** MsInterfaces = MsConfig->MsInterfaces;
+	const LIBUSB_INTERFACE* interface = LibusbConfig->interface;
+
+	for (UINT32 inum = 0; inum < MsConfig->NumInterfaces; inum++)
+	{
+		BYTE alt = MsInterfaces[inum]->AlternateSetting;
+		const LIBUSB_ENDPOINT_DESCEIPTOR* endpoint = interface[inum].altsetting[alt].endpoint;
+
+		for (UINT32 pnum = 0; pnum < MsInterfaces[inum]->NumberOfPipes; pnum++)
+		{
+			if (endpoint[pnum].bEndpointAddress == EndpointAddress)
+			{
+				return &endpoint[pnum];
+			}
+		}
+	}
+
+	return NULL;
+}
+
+static void LIBUSB_CALL func_bulk_transfer_cb(struct libusb_transfer* transfer)
+{
+	ASYNC_TRANSFER_USER_DATA* user_data = NULL;
+	uint32_t streamID = 0;
+	wArrayList* list = NULL;
+
+	user_data = (ASYNC_TRANSFER_USER_DATA*)transfer->user_data;
+	if (!user_data)
+	{
+		WLog_ERR(TAG, "[%s]: Invalid transfer->user_data!");
+		return;
+	}
+	list = user_data->queue;
+	ArrayList_Lock(list);
+	streamID = stream_id_from_buffer(transfer);
+
+	if (list_contains(list, streamID))
+	{
+		const UINT32 InterfaceId =
+		    ((STREAM_ID_PROXY << 30) | user_data->idev->get_ReqCompletion(user_data->idev));
+		const UINT32 RequestID = streamID & INTERFACE_ID_MASK;
+
+		user_data->cb(user_data->idev, user_data->callback, user_data->data, InterfaceId,
+		              user_data->noack, user_data->MessageId, RequestID, transfer->num_iso_packets,
+		              transfer->status, user_data->StartFrame, user_data->ErrorCount,
+		              transfer->actual_length);
+		user_data->data = NULL;
+		ArrayList_Remove(list, transfer);
+	}
+	ArrayList_Unlock(list);
+}
+
+static BOOL func_set_usbd_status(URBDRC_PLUGIN* urbdrc, UDEVICE* pdev, UINT32* status,
+                                 int err_result)
+{
+	if (!urbdrc || !status)
+		return FALSE;
+
+	switch (err_result)
+	{
+		case LIBUSB_SUCCESS:
+			*status = USBD_STATUS_SUCCESS;
+			break;
+
+		case LIBUSB_ERROR_IO:
+			*status = USBD_STATUS_STALL_PID;
+			break;
+
+		case LIBUSB_ERROR_INVALID_PARAM:
+			*status = USBD_STATUS_INVALID_PARAMETER;
+			break;
+
+		case LIBUSB_ERROR_ACCESS:
+			*status = USBD_STATUS_NOT_ACCESSED;
+			break;
+
+		case LIBUSB_ERROR_NO_DEVICE:
+			*status = USBD_STATUS_DEVICE_GONE;
+
+			if (pdev)
+			{
+				if (!(pdev->status & URBDRC_DEVICE_NOT_FOUND))
+					pdev->status |= URBDRC_DEVICE_NOT_FOUND;
+			}
+
+			break;
+
+		case LIBUSB_ERROR_NOT_FOUND:
+			*status = USBD_STATUS_STALL_PID;
+			break;
+
+		case LIBUSB_ERROR_BUSY:
+			*status = USBD_STATUS_STALL_PID;
+			break;
+
+		case LIBUSB_ERROR_TIMEOUT:
+			*status = USBD_STATUS_TIMEOUT;
+			break;
+
+		case LIBUSB_ERROR_OVERFLOW:
+			*status = USBD_STATUS_STALL_PID;
+			break;
+
+		case LIBUSB_ERROR_PIPE:
+			*status = USBD_STATUS_STALL_PID;
+			break;
+
+		case LIBUSB_ERROR_INTERRUPTED:
+			*status = USBD_STATUS_STALL_PID;
+			break;
+
+		case LIBUSB_ERROR_NO_MEM:
+			*status = USBD_STATUS_NO_MEMORY;
+			break;
+
+		case LIBUSB_ERROR_NOT_SUPPORTED:
+			*status = USBD_STATUS_NOT_SUPPORTED;
+			break;
+
+		case LIBUSB_ERROR_OTHER:
+			*status = USBD_STATUS_STALL_PID;
+			break;
+
+		default:
+			*status = USBD_STATUS_SUCCESS;
+			break;
+	}
+
+	return TRUE;
+}
+
+static int func_config_release_all_interface(URBDRC_PLUGIN* urbdrc,
+                                             LIBUSB_DEVICE_HANDLE* libusb_handle,
+                                             UINT32 NumInterfaces)
+{
+	for (UINT32 i = 0; i < NumInterfaces; i++)
+	{
+		int ret = libusb_release_interface(libusb_handle, i);
+
+		if (log_libusb_result(urbdrc->log, WLOG_WARN, "libusb_release_interface", ret))
+			return -1;
+	}
+
+	return 0;
+}
+
+static int func_claim_all_interface(URBDRC_PLUGIN* urbdrc, LIBUSB_DEVICE_HANDLE* libusb_handle,
+                                    int NumInterfaces)
+{
+	int ret = 0;
+
+	for (int i = 0; i < NumInterfaces; i++)
+	{
+		ret = libusb_claim_interface(libusb_handle, i);
+
+		if (log_libusb_result(urbdrc->log, WLOG_ERROR, "libusb_claim_interface", ret))
+			return -1;
+	}
+
+	return 0;
+}
+
+static LIBUSB_DEVICE* udev_get_libusb_dev(libusb_context* context, uint8_t bus_number,
+                                          uint8_t dev_number)
+{
+	LIBUSB_DEVICE** libusb_list = NULL;
+	LIBUSB_DEVICE* device = NULL;
+	const ssize_t total_device = libusb_get_device_list(context, &libusb_list);
+
+	for (ssize_t i = 0; i < total_device; i++)
+	{
+		LIBUSB_DEVICE* dev = libusb_list[i];
+		if ((bus_number == libusb_get_bus_number(dev)) &&
+		    (dev_number == libusb_get_device_address(dev)))
+			device = dev;
+		else
+			libusb_unref_device(dev);
+	}
+
+	libusb_free_device_list(libusb_list, 0);
+	return device;
+}
+
+static LIBUSB_DEVICE_DESCRIPTOR* udev_new_descript(URBDRC_PLUGIN* urbdrc, LIBUSB_DEVICE* libusb_dev)
+{
+	int ret = 0;
+	LIBUSB_DEVICE_DESCRIPTOR* descriptor =
+	    (LIBUSB_DEVICE_DESCRIPTOR*)calloc(1, sizeof(LIBUSB_DEVICE_DESCRIPTOR));
+	if (!descriptor)
+		return NULL;
+	ret = libusb_get_device_descriptor(libusb_dev, descriptor);
+
+	if (log_libusb_result(urbdrc->log, WLOG_ERROR, "libusb_get_device_descriptor", ret))
+	{
+		free(descriptor);
+		return NULL;
+	}
+
+	return descriptor;
+}
+
+static int libusb_udev_select_interface(IUDEVICE* idev, BYTE InterfaceNumber, BYTE AlternateSetting)
+{
+	int error = 0;
+	int diff = 0;
+	UDEVICE* pdev = (UDEVICE*)idev;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	MSUSB_CONFIG_DESCRIPTOR* MsConfig = NULL;
+	MSUSB_INTERFACE_DESCRIPTOR** MsInterfaces = NULL;
+
+	if (!pdev || !pdev->urbdrc)
+		return -1;
+
+	urbdrc = pdev->urbdrc;
+	MsConfig = pdev->MsConfig;
+
+	if (MsConfig)
+	{
+		MsInterfaces = MsConfig->MsInterfaces;
+		if (MsInterfaces)
+		{
+			WLog_Print(urbdrc->log, WLOG_INFO,
+			           "select Interface(%" PRIu8 ") curr AlternateSetting(%" PRIu8
+			           ") new AlternateSetting(%" PRIu8 ")",
+			           InterfaceNumber, MsInterfaces[InterfaceNumber]->AlternateSetting,
+			           AlternateSetting);
+
+			if (MsInterfaces[InterfaceNumber]->AlternateSetting != AlternateSetting)
+			{
+				diff = 1;
+			}
+		}
+
+		if (diff)
+		{
+			error = libusb_set_interface_alt_setting(pdev->libusb_handle, InterfaceNumber,
+			                                         AlternateSetting);
+
+			log_libusb_result(urbdrc->log, WLOG_ERROR, "libusb_set_interface_alt_setting", error);
+		}
+	}
+
+	return error;
+}
+
+static MSUSB_CONFIG_DESCRIPTOR*
+libusb_udev_complete_msconfig_setup(IUDEVICE* idev, MSUSB_CONFIG_DESCRIPTOR* MsConfig)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+	MSUSB_INTERFACE_DESCRIPTOR** MsInterfaces = NULL;
+	MSUSB_INTERFACE_DESCRIPTOR* MsInterface = NULL;
+	MSUSB_PIPE_DESCRIPTOR** MsPipes = NULL;
+	MSUSB_PIPE_DESCRIPTOR* MsPipe = NULL;
+	MSUSB_PIPE_DESCRIPTOR** t_MsPipes = NULL;
+	MSUSB_PIPE_DESCRIPTOR* t_MsPipe = NULL;
+	LIBUSB_CONFIG_DESCRIPTOR* LibusbConfig = NULL;
+	const LIBUSB_INTERFACE* LibusbInterface = NULL;
+	const LIBUSB_INTERFACE_DESCRIPTOR* LibusbAltsetting = NULL;
+	const LIBUSB_ENDPOINT_DESCEIPTOR* LibusbEndpoint = NULL;
+	BYTE LibusbNumEndpoint = 0;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	UINT32 MsOutSize = 0;
+
+	if (!pdev || !pdev->LibusbConfig || !pdev->urbdrc || !MsConfig)
+		return NULL;
+
+	urbdrc = pdev->urbdrc;
+	LibusbConfig = pdev->LibusbConfig;
+
+	if (LibusbConfig->bNumInterfaces != MsConfig->NumInterfaces)
+	{
+		WLog_Print(urbdrc->log, WLOG_ERROR,
+		           "Select Configuration: Libusb NumberInterfaces(%" PRIu8 ") is different "
+		           "with MsConfig NumberInterfaces(%" PRIu32 ")",
+		           LibusbConfig->bNumInterfaces, MsConfig->NumInterfaces);
+	}
+
+	/* replace MsPipes for libusb */
+	MsInterfaces = MsConfig->MsInterfaces;
+
+	for (UINT32 inum = 0; inum < MsConfig->NumInterfaces; inum++)
+	{
+		MsInterface = MsInterfaces[inum];
+		/* get libusb's number of endpoints */
+		LibusbInterface = &LibusbConfig->interface[MsInterface->InterfaceNumber];
+		LibusbAltsetting = &LibusbInterface->altsetting[MsInterface->AlternateSetting];
+		LibusbNumEndpoint = LibusbAltsetting->bNumEndpoints;
+		t_MsPipes =
+		    (MSUSB_PIPE_DESCRIPTOR**)calloc(LibusbNumEndpoint, sizeof(MSUSB_PIPE_DESCRIPTOR*));
+
+		for (UINT32 pnum = 0; pnum < LibusbNumEndpoint; pnum++)
+		{
+			t_MsPipe = (MSUSB_PIPE_DESCRIPTOR*)calloc(1, sizeof(MSUSB_PIPE_DESCRIPTOR));
+
+			if (pnum < MsInterface->NumberOfPipes && MsInterface->MsPipes)
+			{
+				MsPipe = MsInterface->MsPipes[pnum];
+				t_MsPipe->MaximumPacketSize = MsPipe->MaximumPacketSize;
+				t_MsPipe->MaximumTransferSize = MsPipe->MaximumTransferSize;
+				t_MsPipe->PipeFlags = MsPipe->PipeFlags;
+			}
+			else
+			{
+				t_MsPipe->MaximumPacketSize = 0;
+				t_MsPipe->MaximumTransferSize = 0xffffffff;
+				t_MsPipe->PipeFlags = 0;
+			}
+
+			t_MsPipe->PipeHandle = 0;
+			t_MsPipe->bEndpointAddress = 0;
+			t_MsPipe->bInterval = 0;
+			t_MsPipe->PipeType = 0;
+			t_MsPipe->InitCompleted = 0;
+			t_MsPipes[pnum] = t_MsPipe;
+		}
+
+		msusb_mspipes_replace(MsInterface, t_MsPipes, LibusbNumEndpoint);
+	}
+
+	/* setup configuration */
+	MsOutSize = 8;
+	/* ConfigurationHandle:  4 bytes
+	 * ---------------------------------------------------------------
+	 * ||<<< 1 byte >>>|<<< 1 byte >>>|<<<<<<<<<< 2 byte >>>>>>>>>>>||
+	 * ||  bus_number  |  dev_number  |      bConfigurationValue    ||
+	 * ---------------------------------------------------------------
+	 * ***********************/
+	MsConfig->ConfigurationHandle =
+	    MsConfig->bConfigurationValue | (pdev->bus_number << 24) | (pdev->dev_number << 16);
+	MsInterfaces = MsConfig->MsInterfaces;
+
+	for (UINT32 inum = 0; inum < MsConfig->NumInterfaces; inum++)
+	{
+		MsOutSize += 16;
+		MsInterface = MsInterfaces[inum];
+		/* get libusb's interface */
+		LibusbInterface = &LibusbConfig->interface[MsInterface->InterfaceNumber];
+		LibusbAltsetting = &LibusbInterface->altsetting[MsInterface->AlternateSetting];
+		/* InterfaceHandle:  4 bytes
+		 * ---------------------------------------------------------------
+		 * ||<<< 1 byte >>>|<<< 1 byte >>>|<<< 1 byte >>>|<<< 1 byte >>>||
+		 * ||  bus_number  |  dev_number  |  altsetting  | interfaceNum ||
+		 * ---------------------------------------------------------------
+		 * ***********************/
+		MsInterface->InterfaceHandle = LibusbAltsetting->bInterfaceNumber |
+		                               (LibusbAltsetting->bAlternateSetting << 8) |
+		                               (pdev->dev_number << 16) | (pdev->bus_number << 24);
+		MsInterface->Length = 16 + (MsInterface->NumberOfPipes * 20);
+		MsInterface->bInterfaceClass = LibusbAltsetting->bInterfaceClass;
+		MsInterface->bInterfaceSubClass = LibusbAltsetting->bInterfaceSubClass;
+		MsInterface->bInterfaceProtocol = LibusbAltsetting->bInterfaceProtocol;
+		MsInterface->InitCompleted = 1;
+		MsPipes = MsInterface->MsPipes;
+		LibusbNumEndpoint = LibusbAltsetting->bNumEndpoints;
+
+		for (UINT32 pnum = 0; pnum < LibusbNumEndpoint; pnum++)
+		{
+			MsOutSize += 20;
+			MsPipe = MsPipes[pnum];
+			/* get libusb's endpoint */
+			LibusbEndpoint = &LibusbAltsetting->endpoint[pnum];
+			/* PipeHandle:  4 bytes
+			 * ---------------------------------------------------------------
+			 * ||<<< 1 byte >>>|<<< 1 byte >>>|<<<<<<<<<< 2 byte >>>>>>>>>>>||
+			 * ||  bus_number  |  dev_number  |      bEndpointAddress       ||
+			 * ---------------------------------------------------------------
+			 * ***********************/
+			MsPipe->PipeHandle = LibusbEndpoint->bEndpointAddress | (pdev->dev_number << 16) |
+			                     (pdev->bus_number << 24);
+			/* count endpoint max packet size */
+			int max = LibusbEndpoint->wMaxPacketSize & 0x07ff;
+			BYTE attr = LibusbEndpoint->bmAttributes;
+
+			if ((attr & 0x3) == 1 || (attr & 0x3) == 3)
+			{
+				max *= (1 + ((LibusbEndpoint->wMaxPacketSize >> 11) & 3));
+			}
+
+			MsPipe->MaximumPacketSize = max;
+			MsPipe->bEndpointAddress = LibusbEndpoint->bEndpointAddress;
+			MsPipe->bInterval = LibusbEndpoint->bInterval;
+			MsPipe->PipeType = attr & 0x3;
+			MsPipe->InitCompleted = 1;
+		}
+	}
+
+	MsConfig->MsOutSize = MsOutSize;
+	MsConfig->InitCompleted = 1;
+
+	/* replace device's MsConfig */
+	if (MsConfig != pdev->MsConfig)
+	{
+		msusb_msconfig_free(pdev->MsConfig);
+		pdev->MsConfig = MsConfig;
+	}
+
+	return MsConfig;
+}
+
+static int libusb_udev_select_configuration(IUDEVICE* idev, UINT32 bConfigurationValue)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+	MSUSB_CONFIG_DESCRIPTOR* MsConfig = NULL;
+	LIBUSB_DEVICE_HANDLE* libusb_handle = NULL;
+	LIBUSB_DEVICE* libusb_dev = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	LIBUSB_CONFIG_DESCRIPTOR** LibusbConfig = NULL;
+	int ret = 0;
+
+	if (!pdev || !pdev->MsConfig || !pdev->LibusbConfig || !pdev->urbdrc)
+		return -1;
+
+	urbdrc = pdev->urbdrc;
+	MsConfig = pdev->MsConfig;
+	libusb_handle = pdev->libusb_handle;
+	libusb_dev = pdev->libusb_dev;
+	LibusbConfig = &pdev->LibusbConfig;
+
+	if (MsConfig->InitCompleted)
+	{
+		func_config_release_all_interface(pdev->urbdrc, libusb_handle,
+		                                  (*LibusbConfig)->bNumInterfaces);
+	}
+
+	/* The configuration value -1 is mean to put the device in unconfigured state. */
+	if (bConfigurationValue == 0)
+		ret = libusb_set_configuration(libusb_handle, -1);
+	else
+		ret = libusb_set_configuration(libusb_handle, bConfigurationValue);
+
+	if (log_libusb_result(urbdrc->log, WLOG_ERROR, "libusb_set_configuration", ret))
+	{
+		func_claim_all_interface(urbdrc, libusb_handle, (*LibusbConfig)->bNumInterfaces);
+		return -1;
+	}
+	else
+	{
+		ret = libusb_get_active_config_descriptor(libusb_dev, LibusbConfig);
+
+		if (log_libusb_result(urbdrc->log, WLOG_ERROR, "libusb_set_configuration", ret))
+		{
+			func_claim_all_interface(urbdrc, libusb_handle, (*LibusbConfig)->bNumInterfaces);
+			return -1;
+		}
+	}
+
+	func_claim_all_interface(urbdrc, libusb_handle, (*LibusbConfig)->bNumInterfaces);
+	return 0;
+}
+
+static int libusb_udev_control_pipe_request(IUDEVICE* idev, UINT32 RequestId,
+                                            UINT32 EndpointAddress, UINT32* UsbdStatus, int command)
+{
+	int error = 0;
+	UDEVICE* pdev = (UDEVICE*)idev;
+
+	/*
+	pdev->request_queue->register_request(pdev->request_queue, RequestId, NULL, 0);
+	*/
+	switch (command)
+	{
+		case PIPE_CANCEL:
+			/** cancel bulk or int transfer */
+			idev->cancel_all_transfer_request(idev);
+			// dummy_wait_s_obj(1);
+			/** set feature to ep (set halt)*/
+			error = libusb_control_transfer(
+			    pdev->libusb_handle, LIBUSB_ENDPOINT_OUT | LIBUSB_RECIPIENT_ENDPOINT,
+			    LIBUSB_REQUEST_SET_FEATURE, ENDPOINT_HALT, EndpointAddress, NULL, 0, 1000);
+			break;
+
+		case PIPE_RESET:
+			idev->cancel_all_transfer_request(idev);
+			error = libusb_clear_halt(pdev->libusb_handle, EndpointAddress);
+			// func_set_usbd_status(pdev, UsbdStatus, error);
+			break;
+
+		default:
+			error = -0xff;
+			break;
+	}
+
+	*UsbdStatus = 0;
+	return error;
+}
+
+static UINT32 libusb_udev_control_query_device_text(IUDEVICE* idev, UINT32 TextType,
+                                                    UINT16 LocaleId, UINT8* BufferSize,
+                                                    BYTE* Buffer)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+	LIBUSB_DEVICE_DESCRIPTOR* devDescriptor = NULL;
+	const char strDesc[] = "Generic Usb String";
+	char deviceLocation[25] = { 0 };
+	BYTE bus_number = 0;
+	BYTE device_address = 0;
+	int ret = 0;
+	size_t len = 0;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	WCHAR* text = (WCHAR*)Buffer;
+	BYTE slen = 0;
+	BYTE locale = 0;
+	const UINT8 inSize = *BufferSize;
+
+	*BufferSize = 0;
+	if (!pdev || !pdev->devDescriptor || !pdev->urbdrc)
+		return ERROR_INVALID_DATA;
+
+	urbdrc = pdev->urbdrc;
+	devDescriptor = pdev->devDescriptor;
+
+	switch (TextType)
+	{
+		case DeviceTextDescription:
+		{
+			BYTE data[0x100] = { 0 };
+			ret = libusb_get_string_descriptor(pdev->libusb_handle, devDescriptor->iProduct,
+			                                   LocaleId, data, 0xFF);
+			/* The returned data in the buffer is:
+			 * 1 byte  length of following data
+			 * 1 byte  descriptor type, must be 0x03 for strings
+			 * n WCHAR unicode string (of length / 2 characters) including '\0'
+			 */
+			slen = data[0];
+			locale = data[1];
+
+			if ((ret <= 0) || (ret <= 4) || (slen <= 4) || (locale != LIBUSB_DT_STRING) ||
+			    (ret > UINT8_MAX))
+			{
+				const char* msg = "SHORT_DESCRIPTOR";
+				if (ret < 0)
+					msg = libusb_error_name(ret);
+				WLog_Print(urbdrc->log, WLOG_DEBUG,
+				           "libusb_get_string_descriptor: "
+				           "%s [%d], iProduct: %" PRIu8 "!",
+				           msg, ret, devDescriptor->iProduct);
+
+				len = MIN(sizeof(strDesc), inSize);
+				for (ssize_t i = 0; i < len; i++)
+					text[i] = (WCHAR)strDesc[i];
+
+				*BufferSize = (BYTE)(len * 2);
+			}
+			else
+			{
+				/* ret and slen should be equals, but you never know creativity
+				 * of device manufacturers...
+				 * So also check the string length returned as server side does
+				 * not honor strings with multi '\0' characters well.
+				 */
+				const size_t rchar = _wcsnlen((WCHAR*)&data[2], sizeof(data) / 2);
+				len = MIN((BYTE)ret, slen);
+				len = MIN(len, inSize);
+				len = MIN(len, rchar * 2 + sizeof(WCHAR));
+				memcpy(Buffer, &data[2], len);
+
+				/* Just as above, the returned WCHAR string should be '\0'
+				 * terminated, but never trust hardware to conform to specs... */
+				Buffer[len - 2] = '\0';
+				Buffer[len - 1] = '\0';
+				*BufferSize = (BYTE)len;
+			}
+		}
+		break;
+
+		case DeviceTextLocationInformation:
+			bus_number = libusb_get_bus_number(pdev->libusb_dev);
+			device_address = libusb_get_device_address(pdev->libusb_dev);
+			sprintf_s(deviceLocation, sizeof(deviceLocation),
+			          "Port_#%04" PRIu8 ".Hub_#%04" PRIu8 "", device_address, bus_number);
+
+			len = strnlen(deviceLocation,
+			              MIN(sizeof(deviceLocation), (inSize > 0) ? inSize - 1U : 0));
+			for (ssize_t i = 0; i < len; i++)
+				text[i] = (WCHAR)deviceLocation[i];
+			text[len++] = '\0';
+			*BufferSize = (UINT8)(len * sizeof(WCHAR));
+			break;
+
+		default:
+			WLog_Print(urbdrc->log, WLOG_DEBUG, "Query Text: unknown TextType %" PRIu32 "",
+			           TextType);
+			return ERROR_INVALID_DATA;
+	}
+
+	return S_OK;
+}
+
+static int libusb_udev_os_feature_descriptor_request(IUDEVICE* idev, UINT32 RequestId,
+                                                     BYTE Recipient, BYTE InterfaceNumber,
+                                                     BYTE Ms_PageIndex, UINT16 Ms_featureDescIndex,
+                                                     UINT32* UsbdStatus, UINT32* BufferSize,
+                                                     BYTE* Buffer, UINT32 Timeout)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+	BYTE ms_string_desc[0x13] = { 0 };
+	int error = 0;
+
+	WINPR_ASSERT(idev);
+	WINPR_ASSERT(UsbdStatus);
+	WINPR_ASSERT(BufferSize);
+	WINPR_ASSERT(*BufferSize <= UINT16_MAX);
+
+	/*
+	pdev->request_queue->register_request(pdev->request_queue, RequestId, NULL, 0);
+	*/
+	error = libusb_control_transfer(pdev->libusb_handle, LIBUSB_ENDPOINT_IN | Recipient,
+	                                LIBUSB_REQUEST_GET_DESCRIPTOR, 0x03ee, 0, ms_string_desc, 0x12,
+	                                Timeout);
+
+	log_libusb_result(pdev->urbdrc->log, WLOG_DEBUG, "libusb_control_transfer", error);
+
+	if (error > 0)
+	{
+		const BYTE bMS_Vendorcode = ms_string_desc[16];
+		/** get os descriptor */
+		error = libusb_control_transfer(
+		    pdev->libusb_handle, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | Recipient,
+		    bMS_Vendorcode, (UINT16)((InterfaceNumber << 8) | Ms_PageIndex), Ms_featureDescIndex,
+		    Buffer, (UINT16)*BufferSize, Timeout);
+		log_libusb_result(pdev->urbdrc->log, WLOG_DEBUG, "libusb_control_transfer", error);
+
+		if (error >= 0)
+			*BufferSize = (UINT32)error;
+	}
+
+	if (error < 0)
+		*UsbdStatus = USBD_STATUS_STALL_PID;
+	else
+		*UsbdStatus = USBD_STATUS_SUCCESS;
+
+	return ERROR_SUCCESS;
+}
+
+static int libusb_udev_query_device_descriptor(IUDEVICE* idev, int offset)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+
+	switch (offset)
+	{
+		case B_LENGTH:
+			return pdev->devDescriptor->bLength;
+
+		case B_DESCRIPTOR_TYPE:
+			return pdev->devDescriptor->bDescriptorType;
+
+		case BCD_USB:
+			return pdev->devDescriptor->bcdUSB;
+
+		case B_DEVICE_CLASS:
+			return pdev->devDescriptor->bDeviceClass;
+
+		case B_DEVICE_SUBCLASS:
+			return pdev->devDescriptor->bDeviceSubClass;
+
+		case B_DEVICE_PROTOCOL:
+			return pdev->devDescriptor->bDeviceProtocol;
+
+		case B_MAX_PACKET_SIZE0:
+			return pdev->devDescriptor->bMaxPacketSize0;
+
+		case ID_VENDOR:
+			return pdev->devDescriptor->idVendor;
+
+		case ID_PRODUCT:
+			return pdev->devDescriptor->idProduct;
+
+		case BCD_DEVICE:
+			return pdev->devDescriptor->bcdDevice;
+
+		case I_MANUFACTURER:
+			return pdev->devDescriptor->iManufacturer;
+
+		case I_PRODUCT:
+			return pdev->devDescriptor->iProduct;
+
+		case I_SERIAL_NUMBER:
+			return pdev->devDescriptor->iSerialNumber;
+
+		case B_NUM_CONFIGURATIONS:
+			return pdev->devDescriptor->bNumConfigurations;
+
+		default:
+			return 0;
+	}
+}
+
+static BOOL libusb_udev_detach_kernel_driver(IUDEVICE* idev)
+{
+	int err = 0;
+	UDEVICE* pdev = (UDEVICE*)idev;
+	URBDRC_PLUGIN* urbdrc = NULL;
+
+	if (!pdev || !pdev->LibusbConfig || !pdev->libusb_handle || !pdev->urbdrc)
+		return FALSE;
+
+#ifdef _WIN32
+	return TRUE;
+#else
+	urbdrc = pdev->urbdrc;
+
+	if ((pdev->status & URBDRC_DEVICE_DETACH_KERNEL) == 0)
+	{
+		for (int i = 0; i < pdev->LibusbConfig->bNumInterfaces; i++)
+		{
+			err = libusb_kernel_driver_active(pdev->libusb_handle, i);
+			log_libusb_result(urbdrc->log, WLOG_DEBUG, "libusb_kernel_driver_active", err);
+
+			if (err)
+			{
+				err = libusb_detach_kernel_driver(pdev->libusb_handle, i);
+				log_libusb_result(urbdrc->log, WLOG_DEBUG, "libusb_detach_kernel_driver", err);
+			}
+		}
+
+		pdev->status |= URBDRC_DEVICE_DETACH_KERNEL;
+	}
+
+	return TRUE;
+#endif
+}
+
+static BOOL libusb_udev_attach_kernel_driver(IUDEVICE* idev)
+{
+	int err = 0;
+	UDEVICE* pdev = (UDEVICE*)idev;
+
+	if (!pdev || !pdev->LibusbConfig || !pdev->libusb_handle || !pdev->urbdrc)
+		return FALSE;
+
+	for (int i = 0; i < pdev->LibusbConfig->bNumInterfaces && err != LIBUSB_ERROR_NO_DEVICE; i++)
+	{
+		err = libusb_release_interface(pdev->libusb_handle, i);
+
+		log_libusb_result(pdev->urbdrc->log, WLOG_DEBUG, "libusb_release_interface", err);
+
+#ifndef _WIN32
+		if (err != LIBUSB_ERROR_NO_DEVICE)
+		{
+			err = libusb_attach_kernel_driver(pdev->libusb_handle, i);
+			log_libusb_result(pdev->urbdrc->log, WLOG_DEBUG, "libusb_attach_kernel_driver if=%d",
+			                  err, i);
+		}
+#endif
+	}
+
+	return TRUE;
+}
+
+static int libusb_udev_is_composite_device(IUDEVICE* idev)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+	return pdev->isCompositeDevice;
+}
+
+static int libusb_udev_is_exist(IUDEVICE* idev)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+	return (pdev->status & URBDRC_DEVICE_NOT_FOUND) ? 0 : 1;
+}
+
+static int libusb_udev_is_channel_closed(IUDEVICE* idev)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+	IUDEVMAN* udevman = NULL;
+	if (!pdev || !pdev->urbdrc)
+		return 1;
+
+	udevman = pdev->urbdrc->udevman;
+	if (udevman)
+	{
+		if (udevman->status & URBDRC_DEVICE_CHANNEL_CLOSED)
+			return 1;
+	}
+
+	if (pdev->status & URBDRC_DEVICE_CHANNEL_CLOSED)
+		return 1;
+
+	return 0;
+}
+
+static int libusb_udev_is_already_send(IUDEVICE* idev)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+	return (pdev->status & URBDRC_DEVICE_ALREADY_SEND) ? 1 : 0;
+}
+
+/* This is called from channel cleanup code.
+ * Avoid double free, just remove the device and mark the channel closed. */
+static void libusb_udev_mark_channel_closed(IUDEVICE* idev)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+	if (pdev && ((pdev->status & URBDRC_DEVICE_CHANNEL_CLOSED) == 0))
+	{
+		URBDRC_PLUGIN* urbdrc = pdev->urbdrc;
+		const uint8_t busNr = idev->get_bus_number(idev);
+		const uint8_t devNr = idev->get_dev_number(idev);
+
+		pdev->status |= URBDRC_DEVICE_CHANNEL_CLOSED;
+		urbdrc->udevman->unregister_udevice(urbdrc->udevman, busNr, devNr);
+	}
+}
+
+/* This is called by local events where the device is removed or in an error
+ * state. Remove the device from redirection and close the channel. */
+static void libusb_udev_channel_closed(IUDEVICE* idev)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+	if (pdev && ((pdev->status & URBDRC_DEVICE_CHANNEL_CLOSED) == 0))
+	{
+		URBDRC_PLUGIN* urbdrc = pdev->urbdrc;
+		const uint8_t busNr = idev->get_bus_number(idev);
+		const uint8_t devNr = idev->get_dev_number(idev);
+		IWTSVirtualChannel* channel = NULL;
+
+		if (pdev->channelManager)
+			channel = IFCALLRESULT(NULL, pdev->channelManager->FindChannelById,
+			                       pdev->channelManager, pdev->channelID);
+
+		pdev->status |= URBDRC_DEVICE_CHANNEL_CLOSED;
+
+		if (channel)
+			channel->Write(channel, 0, NULL, NULL);
+
+		urbdrc->udevman->unregister_udevice(urbdrc->udevman, busNr, devNr);
+	}
+}
+
+static void libusb_udev_set_already_send(IUDEVICE* idev)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+	pdev->status |= URBDRC_DEVICE_ALREADY_SEND;
+}
+
+static char* libusb_udev_get_path(IUDEVICE* idev)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+	return pdev->path;
+}
+
+static int libusb_udev_query_device_port_status(IUDEVICE* idev, UINT32* UsbdStatus,
+                                                UINT32* BufferSize, BYTE* Buffer)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+	int success = 0;
+	int ret = 0;
+	URBDRC_PLUGIN* urbdrc = NULL;
+
+	if (!pdev || !pdev->urbdrc)
+		return -1;
+
+	urbdrc = pdev->urbdrc;
+
+	if (pdev->hub_handle != NULL)
+	{
+		ret = idev->control_transfer(
+		    idev, 0xffff, 0, 0,
+		    LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_OTHER,
+		    LIBUSB_REQUEST_GET_STATUS, 0, pdev->port_number, UsbdStatus, BufferSize, Buffer, 1000);
+
+		if (log_libusb_result(urbdrc->log, WLOG_DEBUG, "libusb_control_transfer", ret))
+			*BufferSize = 0;
+		else
+		{
+			WLog_Print(urbdrc->log, WLOG_DEBUG,
+			           "PORT STATUS:0x%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "", Buffer[3],
+			           Buffer[2], Buffer[1], Buffer[0]);
+			success = 1;
+		}
+	}
+
+	return success;
+}
+
+static int libusb_udev_isoch_transfer(IUDEVICE* idev, GENERIC_CHANNEL_CALLBACK* callback,
+                                      UINT32 MessageId, UINT32 RequestId, UINT32 EndpointAddress,
+                                      UINT32 TransferFlags, UINT32 StartFrame, UINT32 ErrorCount,
+                                      BOOL NoAck, const BYTE* packetDescriptorData,
+                                      UINT32 NumberOfPackets, UINT32 BufferSize, const BYTE* Buffer,
+                                      t_isoch_transfer_cb cb, UINT32 Timeout)
+{
+	int rc = 0;
+	UINT32 iso_packet_size = 0;
+	UDEVICE* pdev = (UDEVICE*)idev;
+	ASYNC_TRANSFER_USER_DATA* user_data = NULL;
+	struct libusb_transfer* iso_transfer = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	size_t outSize = (NumberOfPackets * 12);
+	uint32_t streamID = 0x40000000 | RequestId;
+
+	if (!pdev || !pdev->urbdrc)
+		return -1;
+
+	urbdrc = pdev->urbdrc;
+	user_data = async_transfer_user_data_new(idev, MessageId, 48, BufferSize, Buffer,
+	                                         outSize + 1024, NoAck, cb, callback);
+
+	if (!user_data)
+		return -1;
+
+	user_data->ErrorCount = ErrorCount;
+	user_data->StartFrame = StartFrame;
+
+	if (!Buffer)
+		Stream_Seek(user_data->data, (NumberOfPackets * 12));
+
+	if (NumberOfPackets > 0)
+	{
+		iso_packet_size = BufferSize / NumberOfPackets;
+		iso_transfer = libusb_alloc_transfer((int)NumberOfPackets);
+	}
+
+	if (iso_transfer == NULL)
+	{
+		WLog_Print(urbdrc->log, WLOG_ERROR,
+		           "Error: libusb_alloc_transfer [NumberOfPackets=%" PRIu32 ", BufferSize=%" PRIu32
+		           " ]",
+		           NumberOfPackets, BufferSize);
+		async_transfer_user_data_free(user_data);
+		return -1;
+	}
+
+	/**  process URB_FUNCTION_IOSCH_TRANSFER */
+	libusb_fill_iso_transfer(iso_transfer, pdev->libusb_handle, EndpointAddress,
+	                         Stream_Pointer(user_data->data), BufferSize, NumberOfPackets,
+	                         func_iso_callback, user_data, Timeout);
+	set_stream_id_for_buffer(iso_transfer, streamID);
+	libusb_set_iso_packet_lengths(iso_transfer, iso_packet_size);
+
+	if (!ArrayList_Append(pdev->request_queue, iso_transfer))
+	{
+		WLog_Print(urbdrc->log, WLOG_WARN,
+		           "Failed to queue iso transfer, streamID %08" PRIx32 " already in use!",
+		           streamID);
+		request_free(iso_transfer);
+		return -1;
+	}
+	rc = libusb_submit_transfer(iso_transfer);
+	if (log_libusb_result(urbdrc->log, WLOG_ERROR, "libusb_submit_transfer", rc))
+		return -1;
+	return rc;
+}
+
+static BOOL libusb_udev_control_transfer(IUDEVICE* idev, UINT32 RequestId, UINT32 EndpointAddress,
+                                         UINT32 TransferFlags, BYTE bmRequestType, BYTE Request,
+                                         UINT16 Value, UINT16 Index, UINT32* UrbdStatus,
+                                         UINT32* BufferSize, BYTE* Buffer, UINT32 Timeout)
+{
+	int status = 0;
+	UDEVICE* pdev = (UDEVICE*)idev;
+
+	WINPR_ASSERT(BufferSize);
+	WINPR_ASSERT(*BufferSize <= UINT16_MAX);
+
+	if (!pdev || !pdev->urbdrc)
+		return FALSE;
+
+	status = libusb_control_transfer(pdev->libusb_handle, bmRequestType, Request, Value, Index,
+	                                 Buffer, (UINT16)*BufferSize, Timeout);
+
+	if (status >= 0)
+		*BufferSize = (UINT32)status;
+	else
+		log_libusb_result(pdev->urbdrc->log, WLOG_ERROR, "libusb_control_transfer", status);
+
+	if (!func_set_usbd_status(pdev->urbdrc, pdev, UrbdStatus, status))
+		return FALSE;
+
+	return TRUE;
+}
+
+static int libusb_udev_bulk_or_interrupt_transfer(IUDEVICE* idev,
+                                                  GENERIC_CHANNEL_CALLBACK* callback,
+                                                  UINT32 MessageId, UINT32 RequestId,
+                                                  UINT32 EndpointAddress, UINT32 TransferFlags,
+                                                  BOOL NoAck, UINT32 BufferSize, const BYTE* data,
+                                                  t_isoch_transfer_cb cb, UINT32 Timeout)
+{
+	int rc = 0;
+	UINT32 transfer_type = 0;
+	UDEVICE* pdev = (UDEVICE*)idev;
+	const LIBUSB_ENDPOINT_DESCEIPTOR* ep_desc = NULL;
+	struct libusb_transfer* transfer = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	ASYNC_TRANSFER_USER_DATA* user_data = NULL;
+	uint32_t streamID = 0x80000000 | RequestId;
+
+	if (!pdev || !pdev->LibusbConfig || !pdev->urbdrc)
+		return -1;
+
+	urbdrc = pdev->urbdrc;
+	user_data =
+	    async_transfer_user_data_new(idev, MessageId, 36, BufferSize, data, 0, NoAck, cb, callback);
+
+	if (!user_data)
+		return -1;
+
+	/* alloc memory for urb transfer */
+	transfer = libusb_alloc_transfer(0);
+	if (!transfer)
+	{
+		async_transfer_user_data_free(user_data);
+		return -1;
+	}
+	transfer->user_data = user_data;
+
+	ep_desc = func_get_ep_desc(pdev->LibusbConfig, pdev->MsConfig, EndpointAddress);
+
+	if (!ep_desc)
+	{
+		WLog_Print(urbdrc->log, WLOG_ERROR, "func_get_ep_desc: endpoint 0x%" PRIx32 " not found",
+		           EndpointAddress);
+		request_free(transfer);
+		return -1;
+	}
+
+	transfer_type = (ep_desc->bmAttributes) & 0x3;
+	WLog_Print(urbdrc->log, WLOG_DEBUG,
+	           "urb_bulk_or_interrupt_transfer: ep:0x%" PRIx32 " "
+	           "transfer_type %" PRIu32 " flag:%" PRIu32 " OutputBufferSize:0x%" PRIx32 "",
+	           EndpointAddress, transfer_type, TransferFlags, BufferSize);
+
+	switch (transfer_type)
+	{
+		case BULK_TRANSFER:
+			/** Bulk Transfer */
+			libusb_fill_bulk_transfer(transfer, pdev->libusb_handle, EndpointAddress,
+			                          Stream_Pointer(user_data->data), BufferSize,
+			                          func_bulk_transfer_cb, user_data, Timeout);
+			break;
+
+		case INTERRUPT_TRANSFER:
+			/**  Interrupt Transfer */
+			libusb_fill_interrupt_transfer(transfer, pdev->libusb_handle, EndpointAddress,
+			                               Stream_Pointer(user_data->data), BufferSize,
+			                               func_bulk_transfer_cb, user_data, Timeout);
+			break;
+
+		default:
+			WLog_Print(urbdrc->log, WLOG_DEBUG,
+			           "urb_bulk_or_interrupt_transfer:"
+			           " other transfer type 0x%" PRIX32 "",
+			           transfer_type);
+			request_free(transfer);
+			return -1;
+	}
+
+	set_stream_id_for_buffer(transfer, streamID);
+
+	if (!ArrayList_Append(pdev->request_queue, transfer))
+	{
+		WLog_Print(urbdrc->log, WLOG_WARN,
+		           "Failed to queue transfer, streamID %08" PRIx32 " already in use!", streamID);
+		request_free(transfer);
+		return -1;
+	}
+	rc = libusb_submit_transfer(transfer);
+	if (log_libusb_result(urbdrc->log, WLOG_ERROR, "libusb_submit_transfer", rc))
+		return -1;
+	return rc;
+}
+
+static int func_cancel_xact_request(URBDRC_PLUGIN* urbdrc, struct libusb_transfer* transfer)
+{
+	int status = 0;
+
+	if (!urbdrc || !transfer)
+		return -1;
+
+	status = libusb_cancel_transfer(transfer);
+
+	if (log_libusb_result(urbdrc->log, WLOG_WARN, "libusb_cancel_transfer", status))
+	{
+		if (status == LIBUSB_ERROR_NOT_FOUND)
+			return -1;
+	}
+	else
+		return 1;
+
+	return 0;
+}
+
+static void libusb_udev_cancel_all_transfer_request(IUDEVICE* idev)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+	size_t count = 0;
+
+	if (!pdev || !pdev->request_queue || !pdev->urbdrc)
+		return;
+
+	ArrayList_Lock(pdev->request_queue);
+	count = ArrayList_Count(pdev->request_queue);
+
+	for (size_t x = 0; x < count; x++)
+	{
+		struct libusb_transfer* transfer = ArrayList_GetItem(pdev->request_queue, x);
+		func_cancel_xact_request(pdev->urbdrc, transfer);
+	}
+
+	ArrayList_Unlock(pdev->request_queue);
+}
+
+static int libusb_udev_cancel_transfer_request(IUDEVICE* idev, UINT32 RequestId)
+{
+	int rc = -1;
+	UDEVICE* pdev = (UDEVICE*)idev;
+	struct libusb_transfer* transfer = NULL;
+	uint32_t cancelID1 = 0x40000000 | RequestId;
+	uint32_t cancelID2 = 0x80000000 | RequestId;
+
+	if (!idev || !pdev->urbdrc || !pdev->request_queue)
+		return -1;
+
+	ArrayList_Lock(pdev->request_queue);
+	transfer = list_contains(pdev->request_queue, cancelID1);
+	if (!transfer)
+		transfer = list_contains(pdev->request_queue, cancelID2);
+
+	if (transfer)
+	{
+		URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*)pdev->urbdrc;
+
+		rc = func_cancel_xact_request(urbdrc, transfer);
+	}
+	ArrayList_Unlock(pdev->request_queue);
+	return rc;
+}
+
+BASIC_STATE_FUNC_DEFINED(channelManager, IWTSVirtualChannelManager*)
+BASIC_STATE_FUNC_DEFINED(channelID, UINT32)
+BASIC_STATE_FUNC_DEFINED(ReqCompletion, UINT32)
+BASIC_STATE_FUNC_DEFINED(bus_number, BYTE)
+BASIC_STATE_FUNC_DEFINED(dev_number, BYTE)
+BASIC_STATE_FUNC_DEFINED(port_number, int)
+BASIC_STATE_FUNC_DEFINED(MsConfig, MSUSB_CONFIG_DESCRIPTOR*)
+
+BASIC_POINT_FUNC_DEFINED(udev, void*)
+BASIC_POINT_FUNC_DEFINED(prev, void*)
+BASIC_POINT_FUNC_DEFINED(next, void*)
+
+static UINT32 udev_get_UsbDevice(IUDEVICE* idev)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+
+	if (!pdev)
+		return 0;
+
+	return pdev->UsbDevice;
+}
+
+static void udev_set_UsbDevice(IUDEVICE* idev, UINT32 val)
+{
+	UDEVICE* pdev = (UDEVICE*)idev;
+
+	if (!pdev)
+		return;
+
+	pdev->UsbDevice = val;
+}
+
+static void udev_free(IUDEVICE* idev)
+{
+	int rc = 0;
+	UDEVICE* udev = (UDEVICE*)idev;
+	URBDRC_PLUGIN* urbdrc = NULL;
+
+	if (!idev || !udev->urbdrc)
+		return;
+
+	urbdrc = udev->urbdrc;
+
+	libusb_udev_cancel_all_transfer_request(&udev->iface);
+	if (udev->libusb_handle)
+	{
+		rc = libusb_reset_device(udev->libusb_handle);
+
+		log_libusb_result(urbdrc->log, WLOG_ERROR, "libusb_reset_device", rc);
+	}
+
+	/* HACK: We need to wait until the cancel transfer has been processed by
+	 * poll_libusb_events
+	 */
+	Sleep(100);
+
+	/* release all interface and  attach kernel driver */
+	udev->iface.attach_kernel_driver(idev);
+	ArrayList_Free(udev->request_queue);
+	/* free the config descriptor that send from windows */
+	msusb_msconfig_free(udev->MsConfig);
+	libusb_unref_device(udev->libusb_dev);
+	libusb_close(udev->libusb_handle);
+	libusb_close(udev->hub_handle);
+	free(udev->devDescriptor);
+	free(idev);
+}
+
+static void udev_load_interface(UDEVICE* pdev)
+{
+	WINPR_ASSERT(pdev);
+
+	/* load interface */
+	/* Basic */
+	BASIC_STATE_FUNC_REGISTER(channelManager, pdev);
+	BASIC_STATE_FUNC_REGISTER(channelID, pdev);
+	BASIC_STATE_FUNC_REGISTER(UsbDevice, pdev);
+	BASIC_STATE_FUNC_REGISTER(ReqCompletion, pdev);
+	BASIC_STATE_FUNC_REGISTER(bus_number, pdev);
+	BASIC_STATE_FUNC_REGISTER(dev_number, pdev);
+	BASIC_STATE_FUNC_REGISTER(port_number, pdev);
+	BASIC_STATE_FUNC_REGISTER(MsConfig, pdev);
+	BASIC_STATE_FUNC_REGISTER(p_udev, pdev);
+	BASIC_STATE_FUNC_REGISTER(p_prev, pdev);
+	BASIC_STATE_FUNC_REGISTER(p_next, pdev);
+	pdev->iface.isCompositeDevice = libusb_udev_is_composite_device;
+	pdev->iface.isExist = libusb_udev_is_exist;
+	pdev->iface.isAlreadySend = libusb_udev_is_already_send;
+	pdev->iface.isChannelClosed = libusb_udev_is_channel_closed;
+	pdev->iface.setAlreadySend = libusb_udev_set_already_send;
+	pdev->iface.setChannelClosed = libusb_udev_channel_closed;
+	pdev->iface.markChannelClosed = libusb_udev_mark_channel_closed;
+	pdev->iface.getPath = libusb_udev_get_path;
+	/* Transfer */
+	pdev->iface.isoch_transfer = libusb_udev_isoch_transfer;
+	pdev->iface.control_transfer = libusb_udev_control_transfer;
+	pdev->iface.bulk_or_interrupt_transfer = libusb_udev_bulk_or_interrupt_transfer;
+	pdev->iface.select_interface = libusb_udev_select_interface;
+	pdev->iface.select_configuration = libusb_udev_select_configuration;
+	pdev->iface.complete_msconfig_setup = libusb_udev_complete_msconfig_setup;
+	pdev->iface.control_pipe_request = libusb_udev_control_pipe_request;
+	pdev->iface.control_query_device_text = libusb_udev_control_query_device_text;
+	pdev->iface.os_feature_descriptor_request = libusb_udev_os_feature_descriptor_request;
+	pdev->iface.cancel_all_transfer_request = libusb_udev_cancel_all_transfer_request;
+	pdev->iface.cancel_transfer_request = libusb_udev_cancel_transfer_request;
+	pdev->iface.query_device_descriptor = libusb_udev_query_device_descriptor;
+	pdev->iface.detach_kernel_driver = libusb_udev_detach_kernel_driver;
+	pdev->iface.attach_kernel_driver = libusb_udev_attach_kernel_driver;
+	pdev->iface.query_device_port_status = libusb_udev_query_device_port_status;
+	pdev->iface.free = udev_free;
+}
+
+static int udev_get_device_handle(URBDRC_PLUGIN* urbdrc, libusb_context* ctx, UDEVICE* pdev,
+                                  UINT16 bus_number, UINT16 dev_number)
+{
+	int error = -1;
+	uint8_t port_numbers[16] = { 0 };
+	LIBUSB_DEVICE** libusb_list = NULL;
+	const ssize_t total_device = libusb_get_device_list(ctx, &libusb_list);
+
+	WINPR_ASSERT(urbdrc);
+
+	/* Look for device. */
+	for (ssize_t i = 0; i < total_device; i++)
+	{
+		LIBUSB_DEVICE* dev = libusb_list[i];
+
+		if ((bus_number != libusb_get_bus_number(dev)) ||
+		    (dev_number != libusb_get_device_address(dev)))
+			libusb_unref_device(dev);
+		else
+		{
+			error = libusb_open(dev, &pdev->libusb_handle);
+
+			if (log_libusb_result(urbdrc->log, WLOG_ERROR, "libusb_open", error))
+			{
+				libusb_unref_device(dev);
+				continue;
+			}
+
+			/* get port number */
+			error = libusb_get_port_numbers(dev, port_numbers, sizeof(port_numbers));
+			if (error < 1)
+			{
+				/* Prevent open hub, treat as error. */
+				log_libusb_result(urbdrc->log, WLOG_ERROR, "libusb_get_port_numbers", error);
+				libusb_unref_device(dev);
+				continue;
+			}
+
+			pdev->port_number = port_numbers[(error - 1)];
+			error = 0;
+			WLog_Print(urbdrc->log, WLOG_DEBUG, "  Port: %d", pdev->port_number);
+			/* gen device path */
+			sprintf(pdev->path, "%" PRIu16 "-%d", bus_number, pdev->port_number);
+
+			WLog_Print(urbdrc->log, WLOG_DEBUG, "  DevPath: %s", pdev->path);
+		}
+	}
+	libusb_free_device_list(libusb_list, 0);
+
+	if (error < 0)
+		return -1;
+	return 0;
+}
+
+static int udev_get_hub_handle(URBDRC_PLUGIN* urbdrc, libusb_context* ctx, UDEVICE* pdev,
+                               UINT16 bus_number, UINT16 dev_number)
+{
+	int error = -1;
+	LIBUSB_DEVICE** libusb_list = NULL;
+	LIBUSB_DEVICE_HANDLE* handle = NULL;
+	const ssize_t total_device = libusb_get_device_list(ctx, &libusb_list);
+
+	WINPR_ASSERT(urbdrc);
+
+	/* Look for device hub. */
+	for (ssize_t i = 0; i < total_device; i++)
+	{
+		LIBUSB_DEVICE* dev = libusb_list[i];
+
+		if ((bus_number != libusb_get_bus_number(dev)) ||
+		    (1 != libusb_get_device_address(dev))) /* Root hub allways first on bus. */
+			libusb_unref_device(dev);
+		else
+		{
+			WLog_Print(urbdrc->log, WLOG_DEBUG, "  Open hub: %" PRIu16 "", bus_number);
+			error = libusb_open(dev, &handle);
+
+			if (!log_libusb_result(urbdrc->log, WLOG_ERROR, "libusb_open", error))
+				pdev->hub_handle = handle;
+			else
+				libusb_unref_device(dev);
+		}
+	}
+
+	libusb_free_device_list(libusb_list, 0);
+
+	if (error < 0)
+		return -1;
+
+	return 0;
+}
+
+static void request_free(void* value)
+{
+	ASYNC_TRANSFER_USER_DATA* user_data = NULL;
+	struct libusb_transfer* transfer = (struct libusb_transfer*)value;
+	if (!transfer)
+		return;
+
+	user_data = (ASYNC_TRANSFER_USER_DATA*)transfer->user_data;
+	async_transfer_user_data_free(user_data);
+	transfer->user_data = NULL;
+	libusb_free_transfer(transfer);
+}
+
+static IUDEVICE* udev_init(URBDRC_PLUGIN* urbdrc, libusb_context* context, LIBUSB_DEVICE* device,
+                           BYTE bus_number, BYTE dev_number)
+{
+	UDEVICE* pdev = NULL;
+	int status = LIBUSB_ERROR_OTHER;
+	LIBUSB_DEVICE_DESCRIPTOR* devDescriptor = NULL;
+	LIBUSB_CONFIG_DESCRIPTOR* config_temp = NULL;
+	LIBUSB_INTERFACE_DESCRIPTOR interface_temp;
+
+	WINPR_ASSERT(urbdrc);
+
+	pdev = (PUDEVICE)calloc(1, sizeof(UDEVICE));
+
+	if (!pdev)
+		return NULL;
+
+	pdev->urbdrc = urbdrc;
+	udev_load_interface(pdev);
+
+	if (device)
+		pdev->libusb_dev = device;
+	else
+		pdev->libusb_dev = udev_get_libusb_dev(context, bus_number, dev_number);
+
+	if (pdev->libusb_dev == NULL)
+		goto fail;
+
+	if (urbdrc->listener_callback)
+		udev_set_channelManager(&pdev->iface, urbdrc->listener_callback->channel_mgr);
+
+	/* Get DEVICE handle */
+	status = udev_get_device_handle(urbdrc, context, pdev, bus_number, dev_number);
+	if (status != LIBUSB_SUCCESS)
+	{
+		struct libusb_device_descriptor desc;
+		const uint8_t port = libusb_get_port_number(pdev->libusb_dev);
+		libusb_get_device_descriptor(pdev->libusb_dev, &desc);
+
+		log_libusb_result(urbdrc->log, WLOG_ERROR,
+		                  "libusb_open [b=0x%02X,p=0x%02X,a=0x%02X,VID=0x%04X,PID=0x%04X]", status,
+		                  bus_number, port, dev_number, desc.idVendor, desc.idProduct);
+		goto fail;
+	}
+
+	/* Get HUB handle */
+	status = udev_get_hub_handle(urbdrc, context, pdev, bus_number, dev_number);
+
+	if (status < 0)
+		pdev->hub_handle = NULL;
+
+	pdev->devDescriptor = udev_new_descript(urbdrc, pdev->libusb_dev);
+
+	if (!pdev->devDescriptor)
+		goto fail;
+
+	status = libusb_get_active_config_descriptor(pdev->libusb_dev, &pdev->LibusbConfig);
+
+	if (status == LIBUSB_ERROR_NOT_FOUND)
+		status = libusb_get_config_descriptor(pdev->libusb_dev, 0, &pdev->LibusbConfig);
+
+	if (status < 0)
+		goto fail;
+
+	config_temp = pdev->LibusbConfig;
+	/* get the first interface and first altsetting */
+	interface_temp = config_temp->interface[0].altsetting[0];
+	WLog_Print(urbdrc->log, WLOG_DEBUG,
+	           "Registered Device: Vid: 0x%04" PRIX16 " Pid: 0x%04" PRIX16 ""
+	           " InterfaceClass = %s",
+	           pdev->devDescriptor->idVendor, pdev->devDescriptor->idProduct,
+	           usb_interface_class_to_string(interface_temp.bInterfaceClass));
+	/* Check composite device */
+	devDescriptor = pdev->devDescriptor;
+
+	if ((devDescriptor->bNumConfigurations == 1) && (config_temp->bNumInterfaces > 1) &&
+	    (devDescriptor->bDeviceClass == LIBUSB_CLASS_PER_INTERFACE))
+	{
+		pdev->isCompositeDevice = 1;
+	}
+	else if ((devDescriptor->bDeviceClass == 0xef) &&
+	         (devDescriptor->bDeviceSubClass == LIBUSB_CLASS_COMM) &&
+	         (devDescriptor->bDeviceProtocol == 0x01))
+	{
+		pdev->isCompositeDevice = 1;
+	}
+	else
+		pdev->isCompositeDevice = 0;
+
+	/* set device class to first interface class */
+	devDescriptor->bDeviceClass = interface_temp.bInterfaceClass;
+	devDescriptor->bDeviceSubClass = interface_temp.bInterfaceSubClass;
+	devDescriptor->bDeviceProtocol = interface_temp.bInterfaceProtocol;
+	/* initialize pdev */
+	pdev->bus_number = bus_number;
+	pdev->dev_number = dev_number;
+	pdev->request_queue = ArrayList_New(TRUE);
+
+	if (!pdev->request_queue)
+		goto fail;
+
+	ArrayList_Object(pdev->request_queue)->fnObjectFree = request_free;
+
+	/* set config of windows */
+	pdev->MsConfig = msusb_msconfig_new();
+
+	if (!pdev->MsConfig)
+		goto fail;
+
+	// deb_config_msg(pdev->libusb_dev, config_temp, devDescriptor->bNumConfigurations);
+	return &pdev->iface;
+fail:
+	pdev->iface.free(&pdev->iface);
+	return NULL;
+}
+
+size_t udev_new_by_id(URBDRC_PLUGIN* urbdrc, libusb_context* ctx, UINT16 idVendor, UINT16 idProduct,
+                      IUDEVICE*** devArray)
+{
+	LIBUSB_DEVICE** libusb_list = NULL;
+	UDEVICE** array = NULL;
+	ssize_t total_device = 0;
+	size_t num = 0;
+
+	if (!urbdrc || !devArray)
+		return 0;
+
+	WLog_Print(urbdrc->log, WLOG_INFO, "VID: 0x%04" PRIX16 ", PID: 0x%04" PRIX16 "", idVendor,
+	           idProduct);
+	total_device = libusb_get_device_list(ctx, &libusb_list);
+	if (total_device < 0)
+		return 0;
+
+	array = (UDEVICE**)calloc((size_t)total_device, sizeof(UDEVICE*));
+
+	if (!array)
+		goto fail;
+
+	for (ssize_t i = 0; i < total_device; i++)
+	{
+		LIBUSB_DEVICE* dev = libusb_list[i];
+		LIBUSB_DEVICE_DESCRIPTOR* descriptor = udev_new_descript(urbdrc, dev);
+
+		if ((descriptor->idVendor == idVendor) && (descriptor->idProduct == idProduct))
+		{
+			array[num] = (PUDEVICE)udev_init(urbdrc, ctx, dev, libusb_get_bus_number(dev),
+			                                 libusb_get_device_address(dev));
+
+			if (array[num] != NULL)
+				num++;
+		}
+		else
+			libusb_unref_device(dev);
+
+		free(descriptor);
+	}
+
+fail:
+	libusb_free_device_list(libusb_list, 0);
+	*devArray = (IUDEVICE**)array;
+	return num;
+}
+
+IUDEVICE* udev_new_by_addr(URBDRC_PLUGIN* urbdrc, libusb_context* context, BYTE bus_number,
+                           BYTE dev_number)
+{
+	WLog_Print(urbdrc->log, WLOG_DEBUG, "bus:%d dev:%d", bus_number, dev_number);
+	return udev_init(urbdrc, context, NULL, bus_number, dev_number);
+}
diff --git a/channels/urbdrc/client/libusb/libusb_udevice.h b/channels/urbdrc/client/libusb/libusb_udevice.h
new file mode 100644
index 0000000..33705e3
--- /dev/null
+++ b/channels/urbdrc/client/libusb/libusb_udevice.h
@@ -0,0 +1,76 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX USB Redirection
+ *
+ * Copyright 2012 Atrust corp.
+ * Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_CHANNEL_URBDRC_CLIENT_LIBUSB_UDEVICE_H
+#define FREERDP_CHANNEL_URBDRC_CLIENT_LIBUSB_UDEVICE_H
+
+#include <winpr/windows.h>
+#include <libusb.h>
+
+#include "urbdrc_types.h"
+#include "urbdrc_main.h"
+
+typedef struct libusb_device LIBUSB_DEVICE;
+typedef struct libusb_device_handle LIBUSB_DEVICE_HANDLE;
+typedef struct libusb_device_descriptor LIBUSB_DEVICE_DESCRIPTOR;
+typedef struct libusb_config_descriptor LIBUSB_CONFIG_DESCRIPTOR;
+typedef struct libusb_interface LIBUSB_INTERFACE;
+typedef struct libusb_interface_descriptor LIBUSB_INTERFACE_DESCRIPTOR;
+typedef struct libusb_endpoint_descriptor LIBUSB_ENDPOINT_DESCEIPTOR;
+
+typedef struct
+{
+	IUDEVICE iface;
+
+	void* udev;
+	void* prev;
+	void* next;
+
+	UINT32 UsbDevice;     /* An unique interface ID */
+	UINT32 ReqCompletion; /* An unique interface ID */
+	IWTSVirtualChannelManager* channelManager;
+	UINT32 channelID;
+	UINT16 status;
+	BYTE bus_number;
+	BYTE dev_number;
+	char path[17];
+	int port_number;
+	int isCompositeDevice;
+
+	LIBUSB_DEVICE_HANDLE* libusb_handle;
+	LIBUSB_DEVICE_HANDLE* hub_handle;
+	LIBUSB_DEVICE* libusb_dev;
+	LIBUSB_DEVICE_DESCRIPTOR* devDescriptor;
+	MSUSB_CONFIG_DESCRIPTOR* MsConfig;
+	LIBUSB_CONFIG_DESCRIPTOR* LibusbConfig;
+
+	wArrayList* request_queue;
+
+	URBDRC_PLUGIN* urbdrc;
+} UDEVICE;
+typedef UDEVICE* PUDEVICE;
+
+size_t udev_new_by_id(URBDRC_PLUGIN* urbdrc, libusb_context* ctx, UINT16 idVendor, UINT16 idProduct,
+                      IUDEVICE*** devArray);
+IUDEVICE* udev_new_by_addr(URBDRC_PLUGIN* urbdrc, libusb_context* ctx, BYTE bus_number,
+                           BYTE dev_number);
+const char* usb_interface_class_to_string(uint8_t class);
+
+#endif /* FREERDP_CHANNEL_URBDRC_CLIENT_LIBUSB_UDEVICE_H */
diff --git a/channels/urbdrc/client/libusb/libusb_udevman.c b/channels/urbdrc/client/libusb/libusb_udevman.c
new file mode 100644
index 0000000..d52c307
--- /dev/null
+++ b/channels/urbdrc/client/libusb/libusb_udevman.c
@@ -0,0 +1,970 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX USB Redirection
+ *
+ * Copyright 2012 Atrust corp.
+ * Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <winpr/crt.h>
+#include <winpr/cmdline.h>
+#include <winpr/collections.h>
+
+#include <freerdp/addin.h>
+
+#include "urbdrc_types.h"
+#include "urbdrc_main.h"
+
+#include "libusb_udevice.h"
+
+#include <libusb.h>
+
+#if !defined(LIBUSB_HOTPLUG_NO_FLAGS)
+#define LIBUSB_HOTPLUG_NO_FLAGS 0
+#endif
+
+#define BASIC_STATE_FUNC_DEFINED(_arg, _type)                   \
+	static _type udevman_get_##_arg(IUDEVMAN* idevman)          \
+	{                                                           \
+		UDEVMAN* udevman = (UDEVMAN*)idevman;                   \
+		return udevman->_arg;                                   \
+	}                                                           \
+	static void udevman_set_##_arg(IUDEVMAN* idevman, _type _t) \
+	{                                                           \
+		UDEVMAN* udevman = (UDEVMAN*)idevman;                   \
+		udevman->_arg = _t;                                     \
+	}
+
+#define BASIC_STATE_FUNC_REGISTER(_arg, _man)    \
+	_man->iface.get_##_arg = udevman_get_##_arg; \
+	_man->iface.set_##_arg = udevman_set_##_arg
+
+typedef struct
+{
+	UINT16 vid;
+	UINT16 pid;
+} VID_PID_PAIR;
+
+typedef struct
+{
+	IUDEVMAN iface;
+
+	IUDEVICE* idev; /* iterator device */
+	IUDEVICE* head; /* head device in linked list */
+	IUDEVICE* tail; /* tail device in linked list */
+
+	LPCSTR devices_vid_pid;
+	LPCSTR devices_addr;
+	wArrayList* hotplug_vid_pids;
+	UINT16 flags;
+	UINT32 device_num;
+	UINT32 next_device_id;
+	UINT32 channel_id;
+
+	HANDLE devman_loading;
+	libusb_context* context;
+	HANDLE thread;
+	BOOL running;
+} UDEVMAN;
+typedef UDEVMAN* PUDEVMAN;
+
+static BOOL poll_libusb_events(UDEVMAN* udevman);
+
+static void udevman_rewind(IUDEVMAN* idevman)
+{
+	UDEVMAN* udevman = (UDEVMAN*)idevman;
+	udevman->idev = udevman->head;
+}
+
+static BOOL udevman_has_next(IUDEVMAN* idevman)
+{
+	UDEVMAN* udevman = (UDEVMAN*)idevman;
+
+	if (!udevman || !udevman->idev)
+		return FALSE;
+	else
+		return TRUE;
+}
+
+static IUDEVICE* udevman_get_next(IUDEVMAN* idevman)
+{
+	UDEVMAN* udevman = (UDEVMAN*)idevman;
+	IUDEVICE* pdev = NULL;
+	pdev = udevman->idev;
+	udevman->idev = (IUDEVICE*)((UDEVICE*)udevman->idev)->next;
+	return pdev;
+}
+
+static IUDEVICE* udevman_get_udevice_by_addr(IUDEVMAN* idevman, BYTE bus_number, BYTE dev_number)
+{
+	IUDEVICE* dev = NULL;
+
+	if (!idevman)
+		return NULL;
+
+	idevman->loading_lock(idevman);
+	idevman->rewind(idevman);
+
+	while (idevman->has_next(idevman))
+	{
+		IUDEVICE* pdev = idevman->get_next(idevman);
+
+		if ((pdev->get_bus_number(pdev) == bus_number) &&
+		    (pdev->get_dev_number(pdev) == dev_number))
+		{
+			dev = pdev;
+			break;
+		}
+	}
+
+	idevman->loading_unlock(idevman);
+	return dev;
+}
+
+static size_t udevman_register_udevice(IUDEVMAN* idevman, BYTE bus_number, BYTE dev_number,
+                                       UINT16 idVendor, UINT16 idProduct, UINT32 flag)
+{
+	UDEVMAN* udevman = (UDEVMAN*)idevman;
+	IUDEVICE* pdev = NULL;
+	IUDEVICE** devArray = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	size_t num = 0;
+	size_t addnum = 0;
+
+	if (!idevman || !idevman->plugin)
+		return 0;
+
+	urbdrc = (URBDRC_PLUGIN*)idevman->plugin;
+	pdev = (IUDEVICE*)udevman_get_udevice_by_addr(idevman, bus_number, dev_number);
+
+	if (pdev != NULL)
+		return 0;
+
+	if (flag & UDEVMAN_FLAG_ADD_BY_ADDR)
+	{
+		UINT32 id = 0;
+		IUDEVICE* tdev = udev_new_by_addr(urbdrc, udevman->context, bus_number, dev_number);
+
+		if (tdev == NULL)
+			return 0;
+
+		id = idevman->get_next_device_id(idevman);
+		tdev->set_UsbDevice(tdev, id);
+		idevman->loading_lock(idevman);
+
+		if (udevman->head == NULL)
+		{
+			/* linked list is empty */
+			udevman->head = tdev;
+			udevman->tail = tdev;
+		}
+		else
+		{
+			/* append device to the end of the linked list */
+			udevman->tail->set_p_next(udevman->tail, tdev);
+			tdev->set_p_prev(tdev, udevman->tail);
+			udevman->tail = tdev;
+		}
+
+		udevman->device_num += 1;
+		idevman->loading_unlock(idevman);
+	}
+	else if (flag & UDEVMAN_FLAG_ADD_BY_VID_PID)
+	{
+		addnum = 0;
+		/* register all device that match pid vid */
+		num = udev_new_by_id(urbdrc, udevman->context, idVendor, idProduct, &devArray);
+
+		if (num == 0)
+		{
+			WLog_Print(urbdrc->log, WLOG_WARN,
+			           "Could not find or redirect any usb devices by id %04x:%04x", idVendor,
+			           idProduct);
+		}
+
+		for (size_t i = 0; i < num; i++)
+		{
+			UINT32 id = 0;
+			IUDEVICE* tdev = devArray[i];
+
+			if (udevman_get_udevice_by_addr(idevman, tdev->get_bus_number(tdev),
+			                                tdev->get_dev_number(tdev)) != NULL)
+			{
+				tdev->free(tdev);
+				devArray[i] = NULL;
+				continue;
+			}
+
+			id = idevman->get_next_device_id(idevman);
+			tdev->set_UsbDevice(tdev, id);
+			idevman->loading_lock(idevman);
+
+			if (udevman->head == NULL)
+			{
+				/* linked list is empty */
+				udevman->head = tdev;
+				udevman->tail = tdev;
+			}
+			else
+			{
+				/* append device to the end of the linked list */
+				udevman->tail->set_p_next(udevman->tail, tdev);
+				tdev->set_p_prev(tdev, udevman->tail);
+				udevman->tail = tdev;
+			}
+
+			udevman->device_num += 1;
+			idevman->loading_unlock(idevman);
+			addnum++;
+		}
+
+		free(devArray);
+		return addnum;
+	}
+	else
+	{
+		WLog_Print(urbdrc->log, WLOG_ERROR, "udevman_register_udevice: Invalid flag=%08" PRIx32,
+		           flag);
+		return 0;
+	}
+
+	return 1;
+}
+
+static BOOL udevman_unregister_udevice(IUDEVMAN* idevman, BYTE bus_number, BYTE dev_number)
+{
+	UDEVMAN* udevman = (UDEVMAN*)idevman;
+	UDEVICE* pdev = NULL;
+	UDEVICE* dev = (UDEVICE*)udevman_get_udevice_by_addr(idevman, bus_number, dev_number);
+
+	if (!dev || !idevman)
+		return FALSE;
+
+	idevman->loading_lock(idevman);
+	idevman->rewind(idevman);
+
+	while (idevman->has_next(idevman))
+	{
+		pdev = (UDEVICE*)idevman->get_next(idevman);
+
+		if (pdev == dev) /* device exists */
+		{
+			/* set previous device to point to next device */
+			if (dev->prev != NULL)
+			{
+				/* unregistered device is not the head */
+				pdev = dev->prev;
+				pdev->next = dev->next;
+			}
+			else
+			{
+				/* unregistered device is the head, update head */
+				udevman->head = (IUDEVICE*)dev->next;
+			}
+
+			/* set next device to point to previous device */
+
+			if (dev->next != NULL)
+			{
+				/* unregistered device is not the tail */
+				pdev = (UDEVICE*)dev->next;
+				pdev->prev = dev->prev;
+			}
+			else
+			{
+				/* unregistered device is the tail, update tail */
+				udevman->tail = (IUDEVICE*)dev->prev;
+			}
+
+			udevman->device_num--;
+			break;
+		}
+	}
+
+	idevman->loading_unlock(idevman);
+
+	if (dev)
+	{
+		dev->iface.free(&dev->iface);
+		return TRUE; /* unregistration successful */
+	}
+
+	/* if we reach this point, the device wasn't found */
+	return FALSE;
+}
+
+static BOOL udevman_unregister_all_udevices(IUDEVMAN* idevman)
+{
+	UDEVMAN* udevman = (UDEVMAN*)idevman;
+
+	if (!idevman)
+		return FALSE;
+
+	if (!udevman->head)
+		return TRUE;
+
+	idevman->loading_lock(idevman);
+	idevman->rewind(idevman);
+
+	while (idevman->has_next(idevman))
+	{
+		UDEVICE* dev = (UDEVICE*)idevman->get_next(idevman);
+
+		if (!dev)
+			continue;
+
+		/* set previous device to point to next device */
+		if (dev->prev != NULL)
+		{
+			/* unregistered device is not the head */
+			UDEVICE* pdev = dev->prev;
+			pdev->next = dev->next;
+		}
+		else
+		{
+			/* unregistered device is the head, update head */
+			udevman->head = (IUDEVICE*)dev->next;
+		}
+
+		/* set next device to point to previous device */
+
+		if (dev->next != NULL)
+		{
+			/* unregistered device is not the tail */
+			UDEVICE* pdev = (UDEVICE*)dev->next;
+			pdev->prev = dev->prev;
+		}
+		else
+		{
+			/* unregistered device is the tail, update tail */
+			udevman->tail = (IUDEVICE*)dev->prev;
+		}
+
+		dev->iface.free(&dev->iface);
+		udevman->device_num--;
+	}
+
+	idevman->loading_unlock(idevman);
+
+	return TRUE;
+}
+
+static int udevman_is_auto_add(IUDEVMAN* idevman)
+{
+	UDEVMAN* udevman = (UDEVMAN*)idevman;
+	return (udevman->flags & UDEVMAN_FLAG_ADD_BY_AUTO) ? 1 : 0;
+}
+
+static IUDEVICE* udevman_get_udevice_by_UsbDevice(IUDEVMAN* idevman, UINT32 UsbDevice)
+{
+	UDEVICE* pdev = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+
+	if (!idevman || !idevman->plugin)
+		return NULL;
+
+	/* Mask highest 2 bits, must be ignored */
+	UsbDevice = UsbDevice & INTERFACE_ID_MASK;
+	urbdrc = (URBDRC_PLUGIN*)idevman->plugin;
+	idevman->loading_lock(idevman);
+	idevman->rewind(idevman);
+
+	while (idevman->has_next(idevman))
+	{
+		pdev = (UDEVICE*)idevman->get_next(idevman);
+
+		if (pdev->UsbDevice == UsbDevice)
+		{
+			idevman->loading_unlock(idevman);
+			return (IUDEVICE*)pdev;
+		}
+	}
+
+	idevman->loading_unlock(idevman);
+	WLog_Print(urbdrc->log, WLOG_WARN, "Failed to find a USB device mapped to deviceId=%08" PRIx32,
+	           UsbDevice);
+	return NULL;
+}
+
+static IUDEVICE* udevman_get_udevice_by_ChannelID(IUDEVMAN* idevman, UINT32 channelID)
+{
+	UDEVICE* pdev = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+
+	if (!idevman || !idevman->plugin)
+		return NULL;
+
+	/* Mask highest 2 bits, must be ignored */
+	urbdrc = (URBDRC_PLUGIN*)idevman->plugin;
+	idevman->loading_lock(idevman);
+	idevman->rewind(idevman);
+
+	while (idevman->has_next(idevman))
+	{
+		pdev = (UDEVICE*)idevman->get_next(idevman);
+
+		if (pdev->channelID == channelID)
+		{
+			idevman->loading_unlock(idevman);
+			return (IUDEVICE*)pdev;
+		}
+	}
+
+	idevman->loading_unlock(idevman);
+	WLog_Print(urbdrc->log, WLOG_WARN, "Failed to find a USB device mapped to channelID=%08" PRIx32,
+	           channelID);
+	return NULL;
+}
+
+static void udevman_loading_lock(IUDEVMAN* idevman)
+{
+	UDEVMAN* udevman = (UDEVMAN*)idevman;
+	WaitForSingleObject(udevman->devman_loading, INFINITE);
+}
+
+static void udevman_loading_unlock(IUDEVMAN* idevman)
+{
+	UDEVMAN* udevman = (UDEVMAN*)idevman;
+	ReleaseMutex(udevman->devman_loading);
+}
+
+BASIC_STATE_FUNC_DEFINED(device_num, UINT32)
+
+static UINT32 udevman_get_next_device_id(IUDEVMAN* idevman)
+{
+	UDEVMAN* udevman = (UDEVMAN*)idevman;
+	return udevman->next_device_id++;
+}
+
+static void udevman_set_next_device_id(IUDEVMAN* idevman, UINT32 _t)
+{
+	UDEVMAN* udevman = (UDEVMAN*)idevman;
+	udevman->next_device_id = _t;
+}
+
+static void udevman_free(IUDEVMAN* idevman)
+{
+	UDEVMAN* udevman = (UDEVMAN*)idevman;
+
+	if (!udevman)
+		return;
+
+	udevman->running = FALSE;
+	if (udevman->thread)
+	{
+		WaitForSingleObject(udevman->thread, INFINITE);
+		CloseHandle(udevman->thread);
+	}
+
+	udevman_unregister_all_udevices(idevman);
+
+	if (udevman->devman_loading)
+		CloseHandle(udevman->devman_loading);
+
+	libusb_exit(udevman->context);
+
+	ArrayList_Free(udevman->hotplug_vid_pids);
+	free(udevman);
+}
+
+static BOOL filter_by_class(uint8_t bDeviceClass, uint8_t bDeviceSubClass)
+{
+	switch (bDeviceClass)
+	{
+		case LIBUSB_CLASS_AUDIO:
+		case LIBUSB_CLASS_HID:
+		case LIBUSB_CLASS_MASS_STORAGE:
+		case LIBUSB_CLASS_HUB:
+		case LIBUSB_CLASS_SMART_CARD:
+			return TRUE;
+		default:
+			break;
+	}
+
+	switch (bDeviceSubClass)
+	{
+		default:
+			break;
+	}
+
+	return FALSE;
+}
+
+static BOOL append(char* dst, size_t length, const char* src)
+{
+	return winpr_str_append(src, dst, length, NULL);
+}
+
+static BOOL device_is_filtered(struct libusb_device* dev,
+                               const struct libusb_device_descriptor* desc,
+                               libusb_hotplug_event event)
+{
+	char buffer[8192] = { 0 };
+	char* what = NULL;
+	BOOL filtered = FALSE;
+	append(buffer, sizeof(buffer), usb_interface_class_to_string(desc->bDeviceClass));
+	if (filter_by_class(desc->bDeviceClass, desc->bDeviceSubClass))
+		filtered = TRUE;
+
+	switch (desc->bDeviceClass)
+	{
+		case LIBUSB_CLASS_PER_INTERFACE:
+		{
+			struct libusb_config_descriptor* config = NULL;
+			int rc = libusb_get_active_config_descriptor(dev, &config);
+			if (rc == LIBUSB_SUCCESS)
+			{
+				for (uint8_t x = 0; x < config->bNumInterfaces; x++)
+				{
+					const struct libusb_interface* ifc = &config->interface[x];
+					for (int y = 0; y < ifc->num_altsetting; y++)
+					{
+						const struct libusb_interface_descriptor* const alt = &ifc->altsetting[y];
+						if (filter_by_class(alt->bInterfaceClass, alt->bInterfaceSubClass))
+							filtered = TRUE;
+
+						append(buffer, sizeof(buffer), "|");
+						append(buffer, sizeof(buffer),
+						       usb_interface_class_to_string(alt->bInterfaceClass));
+					}
+				}
+			}
+			libusb_free_config_descriptor(config);
+		}
+		break;
+		default:
+			break;
+	}
+
+	if (filtered)
+		what = "Filtered";
+	else
+	{
+		switch (event)
+		{
+			case LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT:
+				what = "Hotplug remove";
+				break;
+			case LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED:
+				what = "Hotplug add";
+				break;
+			default:
+				what = "Hotplug unknown";
+				break;
+		}
+	}
+
+	WLog_DBG(TAG, "%s device VID=0x%04X,PID=0x%04X class %s", what, desc->idVendor, desc->idProduct,
+	         buffer);
+	return filtered;
+}
+
+static int LIBUSB_CALL hotplug_callback(struct libusb_context* ctx, struct libusb_device* dev,
+                                        libusb_hotplug_event event, void* user_data)
+{
+	VID_PID_PAIR pair;
+	struct libusb_device_descriptor desc;
+	UDEVMAN* udevman = (UDEVMAN*)user_data;
+	const uint8_t bus = libusb_get_bus_number(dev);
+	const uint8_t addr = libusb_get_device_address(dev);
+	int rc = libusb_get_device_descriptor(dev, &desc);
+
+	WINPR_UNUSED(ctx);
+
+	if (rc != LIBUSB_SUCCESS)
+		return rc;
+
+	switch (event)
+	{
+		case LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED:
+			pair.vid = desc.idVendor;
+			pair.pid = desc.idProduct;
+			if ((ArrayList_Contains(udevman->hotplug_vid_pids, &pair)) ||
+			    (udevman->iface.isAutoAdd(&udevman->iface) &&
+			     !device_is_filtered(dev, &desc, event)))
+			{
+				add_device(&udevman->iface, DEVICE_ADD_FLAG_ALL, bus, addr, desc.idVendor,
+				           desc.idProduct);
+			}
+			break;
+
+		case LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT:
+			del_device(&udevman->iface, DEVICE_ADD_FLAG_ALL, bus, addr, desc.idVendor,
+			           desc.idProduct);
+			break;
+
+		default:
+			break;
+	}
+
+	return 0;
+}
+
+static BOOL udevman_initialize(IUDEVMAN* idevman, UINT32 channelId)
+{
+	UDEVMAN* udevman = (UDEVMAN*)idevman;
+
+	if (!udevman)
+		return FALSE;
+
+	idevman->status &= ~URBDRC_DEVICE_CHANNEL_CLOSED;
+	idevman->controlChannelId = channelId;
+	return TRUE;
+}
+
+static BOOL udevman_vid_pid_pair_equals(const void* objA, const void* objB)
+{
+	const VID_PID_PAIR* a = objA;
+	const VID_PID_PAIR* b = objB;
+
+	return (a->vid == b->vid) && (a->pid == b->pid);
+}
+
+static BOOL udevman_parse_device_id_addr(const char** str, UINT16* id1, UINT16* id2, UINT16 max,
+                                         char split_sign, char delimiter)
+{
+	char* mid = NULL;
+	char* end = NULL;
+	unsigned long rc = 0;
+
+	rc = strtoul(*str, &mid, 16);
+
+	if ((mid == *str) || (*mid != split_sign) || (rc > max))
+		return FALSE;
+
+	*id1 = (UINT16)rc;
+	rc = strtoul(++mid, &end, 16);
+
+	if ((end == mid) || (rc > max))
+		return FALSE;
+
+	*id2 = (UINT16)rc;
+
+	*str += end - *str;
+	if (*end == '\0')
+		return TRUE;
+	if (*end == delimiter)
+	{
+		(*str)++;
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+static BOOL urbdrc_udevman_register_devices(UDEVMAN* udevman, const char* devices, BOOL add_by_addr)
+{
+	const char* pos = devices;
+	VID_PID_PAIR* idpair = NULL;
+	UINT16 id1 = 0;
+	UINT16 id2 = 0;
+
+	while (*pos != '\0')
+	{
+		if (!udevman_parse_device_id_addr(&pos, &id1, &id2, (add_by_addr) ? UINT8_MAX : UINT16_MAX,
+		                                  ':', '#'))
+		{
+			WLog_ERR(TAG, "Invalid device argument: \"%s\"", devices);
+			return FALSE;
+		}
+
+		if (add_by_addr)
+		{
+			add_device(&udevman->iface, DEVICE_ADD_FLAG_BUS | DEVICE_ADD_FLAG_DEV, (UINT8)id1,
+			           (UINT8)id2, 0, 0);
+		}
+		else
+		{
+			idpair = calloc(1, sizeof(VID_PID_PAIR));
+			if (!idpair)
+				return CHANNEL_RC_NO_MEMORY;
+			idpair->vid = id1;
+			idpair->pid = id2;
+			if (!ArrayList_Append(udevman->hotplug_vid_pids, idpair))
+			{
+				free(idpair);
+				return CHANNEL_RC_NO_MEMORY;
+			}
+
+			add_device(&udevman->iface, DEVICE_ADD_FLAG_VENDOR | DEVICE_ADD_FLAG_PRODUCT, 0, 0, id1,
+			           id2);
+		}
+	}
+
+	// NOLINTNEXTLINE(clang-analyzer-unix.Malloc): ArrayList_Append owns idpair
+	return CHANNEL_RC_OK;
+}
+
+static UINT urbdrc_udevman_parse_addin_args(UDEVMAN* udevman, const ADDIN_ARGV* args)
+{
+	LPCSTR devices = NULL;
+
+	for (int x = 0; x < args->argc; x++)
+	{
+		const char* arg = args->argv[x];
+		if (strcmp(arg, "dbg") == 0)
+		{
+			WLog_SetLogLevel(WLog_Get(TAG), WLOG_TRACE);
+		}
+		else if (_strnicmp(arg, "device:", 7) == 0)
+		{
+			/* Redirect all local devices */
+			const char* val = &arg[7];
+			const size_t len = strlen(val);
+			if (strcmp(val, "*") == 0)
+			{
+				udevman->flags |= UDEVMAN_FLAG_ADD_BY_AUTO;
+			}
+			else if (_strnicmp(arg, "USBInstanceID:", 14) == 0)
+			{
+				// TODO: Usb instance ID
+			}
+			else if ((val[0] == '{') && (val[len - 1] == '}'))
+			{
+				// TODO: Usb device class
+			}
+		}
+		else if (_strnicmp(arg, "dev:", 4) == 0)
+		{
+			devices = &arg[4];
+		}
+		else if (_strnicmp(arg, "id", 2) == 0)
+		{
+			const char* p = strchr(arg, ':');
+			if (p)
+				udevman->devices_vid_pid = p + 1;
+			else
+				udevman->flags = UDEVMAN_FLAG_ADD_BY_VID_PID;
+		}
+		else if (_strnicmp(arg, "addr", 4) == 0)
+		{
+			const char* p = strchr(arg, ':');
+			if (p)
+				udevman->devices_addr = p + 1;
+			else
+				udevman->flags = UDEVMAN_FLAG_ADD_BY_ADDR;
+		}
+		else if (strcmp(arg, "auto") == 0)
+		{
+			udevman->flags |= UDEVMAN_FLAG_ADD_BY_AUTO;
+		}
+		else
+		{
+			const size_t len = strlen(arg);
+			if ((arg[0] == '{') && (arg[len - 1] == '}'))
+			{
+				// TODO: Check for  {Device Setup Class GUID}:
+			}
+		}
+	}
+	if (devices)
+	{
+		if (udevman->flags & UDEVMAN_FLAG_ADD_BY_VID_PID)
+			udevman->devices_vid_pid = devices;
+		else if (udevman->flags & UDEVMAN_FLAG_ADD_BY_ADDR)
+			udevman->devices_addr = devices;
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+static UINT udevman_listener_created_callback(IUDEVMAN* iudevman)
+{
+	UINT status = 0;
+	UDEVMAN* udevman = (UDEVMAN*)iudevman;
+
+	if (udevman->devices_vid_pid)
+	{
+		status = urbdrc_udevman_register_devices(udevman, udevman->devices_vid_pid, FALSE);
+		if (status != CHANNEL_RC_OK)
+			return status;
+	}
+
+	if (udevman->devices_addr)
+		return urbdrc_udevman_register_devices(udevman, udevman->devices_addr, TRUE);
+
+	return CHANNEL_RC_OK;
+}
+
+static void udevman_load_interface(UDEVMAN* udevman)
+{
+	/* standard */
+	udevman->iface.free = udevman_free;
+	/* manage devices */
+	udevman->iface.rewind = udevman_rewind;
+	udevman->iface.get_next = udevman_get_next;
+	udevman->iface.has_next = udevman_has_next;
+	udevman->iface.register_udevice = udevman_register_udevice;
+	udevman->iface.unregister_udevice = udevman_unregister_udevice;
+	udevman->iface.get_udevice_by_UsbDevice = udevman_get_udevice_by_UsbDevice;
+	udevman->iface.get_udevice_by_ChannelID = udevman_get_udevice_by_ChannelID;
+	/* Extension */
+	udevman->iface.isAutoAdd = udevman_is_auto_add;
+	/* Basic state */
+	BASIC_STATE_FUNC_REGISTER(device_num, udevman);
+	BASIC_STATE_FUNC_REGISTER(next_device_id, udevman);
+
+	/* control semaphore or mutex lock */
+	udevman->iface.loading_lock = udevman_loading_lock;
+	udevman->iface.loading_unlock = udevman_loading_unlock;
+	udevman->iface.initialize = udevman_initialize;
+	udevman->iface.listener_created_callback = udevman_listener_created_callback;
+}
+
+static BOOL poll_libusb_events(UDEVMAN* udevman)
+{
+	int rc = LIBUSB_SUCCESS;
+	struct timeval tv = { 0, 500 };
+	if (libusb_try_lock_events(udevman->context) == 0)
+	{
+		if (libusb_event_handling_ok(udevman->context))
+		{
+			rc = libusb_handle_events_locked(udevman->context, &tv);
+			if (rc != LIBUSB_SUCCESS)
+				WLog_WARN(TAG, "libusb_handle_events_locked %d", rc);
+		}
+		libusb_unlock_events(udevman->context);
+	}
+	else
+	{
+		libusb_lock_event_waiters(udevman->context);
+		if (libusb_event_handler_active(udevman->context))
+		{
+			rc = libusb_wait_for_event(udevman->context, &tv);
+			if (rc < LIBUSB_SUCCESS)
+				WLog_WARN(TAG, "libusb_wait_for_event %d", rc);
+		}
+		libusb_unlock_event_waiters(udevman->context);
+	}
+
+	return rc > 0;
+}
+
+static DWORD WINAPI poll_thread(LPVOID lpThreadParameter)
+{
+	libusb_hotplug_callback_handle handle = 0;
+	UDEVMAN* udevman = (UDEVMAN*)lpThreadParameter;
+	BOOL hasHotplug = libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG);
+
+	if (hasHotplug)
+	{
+		int rc = libusb_hotplug_register_callback(
+		    udevman->context,
+		    LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT,
+		    LIBUSB_HOTPLUG_NO_FLAGS, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
+		    LIBUSB_HOTPLUG_MATCH_ANY, hotplug_callback, udevman, &handle);
+
+		if (rc != LIBUSB_SUCCESS)
+			udevman->running = FALSE;
+	}
+	else
+		WLog_WARN(TAG, "Platform does not support libusb hotplug. USB devices plugged in later "
+		               "will not be detected.");
+
+	while (udevman->running)
+	{
+		poll_libusb_events(udevman);
+	}
+
+	if (hasHotplug)
+		libusb_hotplug_deregister_callback(udevman->context, handle);
+
+	/* Process remaining usb events */
+	while (poll_libusb_events(udevman))
+		;
+
+	ExitThread(0);
+	return 0;
+}
+
+FREERDP_ENTRY_POINT(UINT libusb_freerdp_urbdrc_client_subsystem_entry(
+    PFREERDP_URBDRC_SERVICE_ENTRY_POINTS pEntryPoints))
+{
+	wObject* obj = NULL;
+	UINT rc = 0;
+	UINT status = 0;
+	UDEVMAN* udevman = NULL;
+	const ADDIN_ARGV* args = pEntryPoints->args;
+	udevman = (PUDEVMAN)calloc(1, sizeof(UDEVMAN));
+
+	if (!udevman)
+		goto fail;
+
+	udevman->hotplug_vid_pids = ArrayList_New(TRUE);
+	if (!udevman->hotplug_vid_pids)
+		goto fail;
+	obj = ArrayList_Object(udevman->hotplug_vid_pids);
+	obj->fnObjectFree = free;
+	obj->fnObjectEquals = udevman_vid_pid_pair_equals;
+
+	udevman->next_device_id = BASE_USBDEVICE_NUM;
+	udevman->iface.plugin = pEntryPoints->plugin;
+	rc = libusb_init(&udevman->context);
+
+	if (rc != LIBUSB_SUCCESS)
+		goto fail;
+
+#ifdef _WIN32
+#if LIBUSB_API_VERSION >= 0x01000106
+	/* Prefer usbDK backend on windows. Not supported on other platforms. */
+	rc = libusb_set_option(udevman->context, LIBUSB_OPTION_USE_USBDK);
+	switch (rc)
+	{
+		case LIBUSB_SUCCESS:
+			break;
+		case LIBUSB_ERROR_NOT_FOUND:
+		case LIBUSB_ERROR_NOT_SUPPORTED:
+			WLog_WARN(TAG, "LIBUSB_OPTION_USE_USBDK %s [%d]", libusb_strerror(rc), rc);
+			break;
+		default:
+			WLog_ERR(TAG, "LIBUSB_OPTION_USE_USBDK %s [%d]", libusb_strerror(rc), rc);
+			goto fail;
+	}
+#endif
+#endif
+
+	udevman->flags = UDEVMAN_FLAG_ADD_BY_VID_PID;
+	udevman->devman_loading = CreateMutexA(NULL, FALSE, "devman_loading");
+
+	if (!udevman->devman_loading)
+		goto fail;
+
+	/* load usb device service management */
+	udevman_load_interface(udevman);
+	status = urbdrc_udevman_parse_addin_args(udevman, args);
+
+	if (status != CHANNEL_RC_OK)
+		goto fail;
+
+	udevman->running = TRUE;
+	udevman->thread = CreateThread(NULL, 0, poll_thread, udevman, 0, NULL);
+
+	if (!udevman->thread)
+		goto fail;
+
+	if (!pEntryPoints->pRegisterUDEVMAN(pEntryPoints->plugin, (IUDEVMAN*)udevman))
+		goto fail;
+
+	WLog_DBG(TAG, "UDEVMAN device registered.");
+	return 0;
+fail:
+	udevman_free(&udevman->iface);
+	return ERROR_INTERNAL_ERROR;
+}
diff --git a/channels/urbdrc/client/urbdrc_main.c b/channels/urbdrc/client/urbdrc_main.c
new file mode 100644
index 0000000..96e443d
--- /dev/null
+++ b/channels/urbdrc/client/urbdrc_main.c
@@ -0,0 +1,1023 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX USB Redirection
+ *
+ * Copyright 2012 Atrust corp.
+ * Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <winpr/assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <winpr/pool.h>
+#include <winpr/print.h>
+
+#include <winpr/crt.h>
+#include <winpr/synch.h>
+#include <winpr/string.h>
+#include <winpr/cmdline.h>
+
+#include <freerdp/dvc.h>
+#include <freerdp/addin.h>
+#include <freerdp/channels/log.h>
+#include <freerdp/channels/urbdrc.h>
+
+#include "urbdrc_types.h"
+#include "urbdrc_main.h"
+#include "data_transfer.h"
+
+#include <urbdrc_helpers.h>
+
+static IWTSVirtualChannel* get_channel(IUDEVMAN* idevman)
+{
+	IWTSVirtualChannelManager* channel_mgr = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+
+	if (!idevman)
+		return NULL;
+
+	urbdrc = (URBDRC_PLUGIN*)idevman->plugin;
+
+	if (!urbdrc || !urbdrc->listener_callback)
+		return NULL;
+
+	channel_mgr = urbdrc->listener_callback->channel_mgr;
+
+	if (!channel_mgr)
+		return NULL;
+
+	return channel_mgr->FindChannelById(channel_mgr, idevman->controlChannelId);
+}
+
+static int func_container_id_generate(IUDEVICE* pdev, char* strContainerId)
+{
+	char* p = NULL;
+	char* path = NULL;
+	UINT8 containerId[17] = { 0 };
+	UINT16 idVendor = 0;
+	UINT16 idProduct = 0;
+	idVendor = (UINT16)pdev->query_device_descriptor(pdev, ID_VENDOR);
+	idProduct = (UINT16)pdev->query_device_descriptor(pdev, ID_PRODUCT);
+	path = pdev->getPath(pdev);
+
+	if (strlen(path) > 8)
+		p = (path + strlen(path)) - 8;
+	else
+		p = path;
+
+	sprintf_s((char*)containerId, sizeof(containerId), "%04" PRIX16 "%04" PRIX16 "%s", idVendor,
+	          idProduct, p);
+	/* format */
+	sprintf_s(strContainerId, DEVICE_CONTAINER_STR_SIZE,
+	          "{%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "-%02" PRIx8 "%02" PRIx8 "-%02" PRIx8
+	          "%02" PRIx8 "-%02" PRIx8 "%02" PRIx8 "-%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "%02" PRIx8
+	          "%02" PRIx8 "%02" PRIx8 "}",
+	          containerId[0], containerId[1], containerId[2], containerId[3], containerId[4],
+	          containerId[5], containerId[6], containerId[7], containerId[8], containerId[9],
+	          containerId[10], containerId[11], containerId[12], containerId[13], containerId[14],
+	          containerId[15]);
+	return 0;
+}
+
+static int func_instance_id_generate(IUDEVICE* pdev, char* strInstanceId, size_t len)
+{
+	char instanceId[17] = { 0 };
+	sprintf_s(instanceId, sizeof(instanceId), "\\%s", pdev->getPath(pdev));
+	/* format */
+	sprintf_s(strInstanceId, len,
+	          "%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "-%02" PRIx8 "%02" PRIx8 "-%02" PRIx8
+	          "%02" PRIx8 "-%02" PRIx8 "%02" PRIx8 "-%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "%02" PRIx8
+	          "%02" PRIx8 "%02" PRIx8 "",
+	          instanceId[0], instanceId[1], instanceId[2], instanceId[3], instanceId[4],
+	          instanceId[5], instanceId[6], instanceId[7], instanceId[8], instanceId[9],
+	          instanceId[10], instanceId[11], instanceId[12], instanceId[13], instanceId[14],
+	          instanceId[15]);
+	return 0;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT urbdrc_process_capability_request(GENERIC_CHANNEL_CALLBACK* callback, wStream* s,
+                                              UINT32 MessageId)
+{
+	UINT32 InterfaceId = 0;
+	UINT32 Version = 0;
+	UINT32 out_size = 0;
+	wStream* out = NULL;
+
+	if (!callback || !s)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT32(s, Version);
+
+	if (Version > RIM_CAPABILITY_VERSION_01)
+		Version = RIM_CAPABILITY_VERSION_01;
+
+	InterfaceId = ((STREAM_ID_NONE << 30) | CAPABILITIES_NEGOTIATOR);
+	out_size = 16;
+	out = Stream_New(NULL, out_size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Write_UINT32(out, InterfaceId); /* interface id */
+	Stream_Write_UINT32(out, MessageId);   /* message id */
+	Stream_Write_UINT32(out, Version);     /* usb protocol version */
+	Stream_Write_UINT32(out, 0x00000000);  /* HRESULT */
+	return stream_write_and_free(callback->plugin, callback->channel, out);
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT urbdrc_process_channel_create(GENERIC_CHANNEL_CALLBACK* callback, wStream* s,
+                                          UINT32 MessageId)
+{
+	UINT32 InterfaceId = 0;
+	UINT32 out_size = 0;
+	UINT32 MajorVersion = 0;
+	UINT32 MinorVersion = 0;
+	UINT32 Capabilities = 0;
+	wStream* out = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+
+	if (!callback || !s || !callback->plugin)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 12))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT32(s, MajorVersion);
+	Stream_Read_UINT32(s, MinorVersion);
+	Stream_Read_UINT32(s, Capabilities);
+
+	/* Version check, we only support version 1.0 */
+	if ((MajorVersion != 1) || (MinorVersion != 0))
+	{
+		WLog_Print(urbdrc->log, WLOG_WARN,
+		           "server supports USB channel version %" PRIu32 ".%" PRIu32);
+		WLog_Print(urbdrc->log, WLOG_WARN, "we only support channel version 1.0");
+		MajorVersion = 1;
+		MinorVersion = 0;
+	}
+
+	InterfaceId = ((STREAM_ID_PROXY << 30) | CLIENT_CHANNEL_NOTIFICATION);
+	out_size = 24;
+	out = Stream_New(NULL, out_size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Write_UINT32(out, InterfaceId);     /* interface id */
+	Stream_Write_UINT32(out, MessageId);       /* message id */
+	Stream_Write_UINT32(out, CHANNEL_CREATED); /* function id */
+	Stream_Write_UINT32(out, MajorVersion);
+	Stream_Write_UINT32(out, MinorVersion);
+	Stream_Write_UINT32(out, Capabilities); /* capabilities version */
+	return stream_write_and_free(callback->plugin, callback->channel, out);
+}
+
+static UINT urdbrc_send_virtual_channel_add(IWTSPlugin* plugin, IWTSVirtualChannel* channel,
+                                            UINT32 MessageId)
+{
+	const UINT32 InterfaceId = ((STREAM_ID_PROXY << 30) | CLIENT_DEVICE_SINK);
+	wStream* out = Stream_New(NULL, 12);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Write_UINT32(out, InterfaceId);         /* interface */
+	Stream_Write_UINT32(out, MessageId);           /* message id */
+	Stream_Write_UINT32(out, ADD_VIRTUAL_CHANNEL); /* function id */
+	return stream_write_and_free(plugin, channel, out);
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT urdbrc_send_usb_device_add(GENERIC_CHANNEL_CALLBACK* callback, IUDEVICE* pdev)
+{
+	wStream* out = NULL;
+	UINT32 InterfaceId = 0;
+	char HardwareIds[2][DEVICE_HARDWARE_ID_SIZE] = { { 0 } };
+	char CompatibilityIds[3][DEVICE_COMPATIBILITY_ID_SIZE] = { { 0 } };
+	char strContainerId[DEVICE_CONTAINER_STR_SIZE] = { 0 };
+	char strInstanceId[DEVICE_INSTANCE_STR_SIZE] = { 0 };
+	const char* composite_str = "USB\\COMPOSITE";
+	const size_t composite_len = 13;
+	size_t size = 0;
+	size_t CompatibilityIdLen[3];
+	size_t HardwareIdsLen[2];
+	size_t ContainerIdLen = 0;
+	size_t InstanceIdLen = 0;
+	size_t cchCompatIds = 0;
+	UINT32 bcdUSB = 0;
+	InterfaceId = ((STREAM_ID_PROXY << 30) | CLIENT_DEVICE_SINK);
+	/* USB kernel driver detach!! */
+	pdev->detach_kernel_driver(pdev);
+	{
+		const UINT16 idVendor = (UINT16)pdev->query_device_descriptor(pdev, ID_VENDOR);
+		const UINT16 idProduct = (UINT16)pdev->query_device_descriptor(pdev, ID_PRODUCT);
+		const UINT16 bcdDevice = (UINT16)pdev->query_device_descriptor(pdev, BCD_DEVICE);
+		sprintf_s(HardwareIds[1], DEVICE_HARDWARE_ID_SIZE,
+		          "USB\\VID_%04" PRIX16 "&PID_%04" PRIX16 "", idVendor, idProduct);
+		sprintf_s(HardwareIds[0], DEVICE_HARDWARE_ID_SIZE,
+		          "USB\\VID_%04" PRIX16 "&PID_%04" PRIX16 "&REV_%04" PRIX16 "", idVendor, idProduct,
+		          bcdDevice);
+	}
+	{
+		const UINT8 bDeviceClass = (UINT8)pdev->query_device_descriptor(pdev, B_DEVICE_CLASS);
+		const UINT8 bDeviceSubClass = (UINT8)pdev->query_device_descriptor(pdev, B_DEVICE_SUBCLASS);
+		const UINT8 bDeviceProtocol = (UINT8)pdev->query_device_descriptor(pdev, B_DEVICE_PROTOCOL);
+
+		if (!(pdev->isCompositeDevice(pdev)))
+		{
+			sprintf_s(CompatibilityIds[2], DEVICE_COMPATIBILITY_ID_SIZE, "USB\\Class_%02" PRIX8 "",
+			          bDeviceClass);
+			sprintf_s(CompatibilityIds[1], DEVICE_COMPATIBILITY_ID_SIZE,
+			          "USB\\Class_%02" PRIX8 "&SubClass_%02" PRIX8 "", bDeviceClass,
+			          bDeviceSubClass);
+			sprintf_s(CompatibilityIds[0], DEVICE_COMPATIBILITY_ID_SIZE,
+			          "USB\\Class_%02" PRIX8 "&SubClass_%02" PRIX8 "&Prot_%02" PRIX8 "",
+			          bDeviceClass, bDeviceSubClass, bDeviceProtocol);
+		}
+		else
+		{
+			sprintf_s(CompatibilityIds[2], DEVICE_COMPATIBILITY_ID_SIZE, "USB\\DevClass_00");
+			sprintf_s(CompatibilityIds[1], DEVICE_COMPATIBILITY_ID_SIZE,
+			          "USB\\DevClass_00&SubClass_00");
+			sprintf_s(CompatibilityIds[0], DEVICE_COMPATIBILITY_ID_SIZE,
+			          "USB\\DevClass_00&SubClass_00&Prot_00");
+		}
+	}
+	func_instance_id_generate(pdev, strInstanceId, DEVICE_INSTANCE_STR_SIZE);
+	func_container_id_generate(pdev, strContainerId);
+	CompatibilityIdLen[0] = strnlen(CompatibilityIds[0], sizeof(CompatibilityIds[0]));
+	CompatibilityIdLen[1] = strnlen(CompatibilityIds[1], sizeof(CompatibilityIds[1]));
+	CompatibilityIdLen[2] = strnlen(CompatibilityIds[2], sizeof(CompatibilityIds[2]));
+	HardwareIdsLen[0] = strnlen(HardwareIds[0], sizeof(HardwareIds[0]));
+	HardwareIdsLen[1] = strnlen(HardwareIds[1], sizeof(HardwareIds[1]));
+	cchCompatIds =
+	    CompatibilityIdLen[0] + 1 + CompatibilityIdLen[1] + 1 + CompatibilityIdLen[2] + 2;
+	InstanceIdLen = strnlen(strInstanceId, sizeof(strInstanceId));
+	ContainerIdLen = strnlen(strContainerId, sizeof(strContainerId));
+
+	if (pdev->isCompositeDevice(pdev))
+		cchCompatIds += composite_len + 1;
+
+	size = 24;
+	size += (InstanceIdLen + 1) * 2 + (HardwareIdsLen[0] + 1) * 2 + 4 +
+	        (HardwareIdsLen[1] + 1) * 2 + 2 + 4 + (cchCompatIds)*2 + (ContainerIdLen + 1) * 2 + 4 +
+	        28;
+	out = Stream_New(NULL, size);
+
+	if (!out)
+		return ERROR_OUTOFMEMORY;
+
+	Stream_Write_UINT32(out, InterfaceId); /* interface */
+	Stream_Write_UINT32(out, 0);
+	Stream_Write_UINT32(out, ADD_DEVICE);                /* function id */
+	Stream_Write_UINT32(out, 0x00000001);                /* NumUsbDevice */
+	Stream_Write_UINT32(out, pdev->get_UsbDevice(pdev)); /* UsbDevice */
+	Stream_Write_UINT32(out, (UINT32)InstanceIdLen + 1); /* cchDeviceInstanceId */
+	if (Stream_Write_UTF16_String_From_UTF8(out, InstanceIdLen, strInstanceId, InstanceIdLen,
+	                                        TRUE) < 0)
+		goto fail;
+	Stream_Write_UINT16(out, 0);
+	Stream_Write_UINT32(out, HardwareIdsLen[0] + HardwareIdsLen[1] + 3); /* cchHwIds */
+	                                                                     /* HardwareIds 1 */
+	if (Stream_Write_UTF16_String_From_UTF8(out, HardwareIdsLen[0], HardwareIds[0],
+	                                        HardwareIdsLen[0], TRUE) < 0)
+		goto fail;
+	Stream_Write_UINT16(out, 0);
+	if (Stream_Write_UTF16_String_From_UTF8(out, HardwareIdsLen[1], HardwareIds[1],
+	                                        HardwareIdsLen[1], TRUE) < 0)
+		goto fail;
+	Stream_Write_UINT16(out, 0);
+	Stream_Write_UINT16(out, 0);                    /* add "\0" */
+	Stream_Write_UINT32(out, (UINT32)cchCompatIds); /* cchCompatIds */
+	/* CompatibilityIds */
+	if (Stream_Write_UTF16_String_From_UTF8(out, CompatibilityIdLen[0], CompatibilityIds[0],
+	                                        CompatibilityIdLen[0], TRUE) < 0)
+		goto fail;
+	Stream_Write_UINT16(out, 0);
+	if (Stream_Write_UTF16_String_From_UTF8(out, CompatibilityIdLen[1], CompatibilityIds[1],
+	                                        CompatibilityIdLen[1], TRUE) < 0)
+		goto fail;
+	Stream_Write_UINT16(out, 0);
+	if (Stream_Write_UTF16_String_From_UTF8(out, CompatibilityIdLen[2], CompatibilityIds[2],
+	                                        CompatibilityIdLen[2], TRUE) < 0)
+		goto fail;
+	Stream_Write_UINT16(out, 0);
+
+	if (pdev->isCompositeDevice(pdev))
+	{
+		if (Stream_Write_UTF16_String_From_UTF8(out, composite_len, composite_str, composite_len,
+		                                        TRUE) < 0)
+			goto fail;
+		Stream_Write_UINT16(out, 0);
+	}
+
+	Stream_Write_UINT16(out, 0x0000);                     /* add "\0" */
+	Stream_Write_UINT32(out, (UINT32)ContainerIdLen + 1); /* cchContainerId */
+	/* ContainerId */
+	if (Stream_Write_UTF16_String_From_UTF8(out, ContainerIdLen, strContainerId, ContainerIdLen,
+	                                        TRUE) < 0)
+		goto fail;
+	Stream_Write_UINT16(out, 0);
+	/* USB_DEVICE_CAPABILITIES 28 bytes */
+	Stream_Write_UINT32(out, 0x0000001c);                                /* CbSize */
+	Stream_Write_UINT32(out, 2); /* UsbBusInterfaceVersion, 0 ,1 or 2 */ // TODO: Get from libusb
+	Stream_Write_UINT32(out, 0x600); /* USBDI_Version, 0x500 or 0x600 */ // TODO: Get from libusb
+	/* Supported_USB_Version, 0x110,0x110 or 0x200(usb2.0) */
+	bcdUSB = pdev->query_device_descriptor(pdev, BCD_USB);
+	Stream_Write_UINT32(out, bcdUSB);
+	Stream_Write_UINT32(out, 0x00000000); /* HcdCapabilities, MUST always be zero */
+
+	if (bcdUSB < 0x200)
+		Stream_Write_UINT32(out, 0x00000000); /* DeviceIsHighSpeed */
+	else
+		Stream_Write_UINT32(out, 0x00000001); /* DeviceIsHighSpeed */
+
+	Stream_Write_UINT32(out, 0x50); /* NoAckIsochWriteJitterBufferSizeInMs, >=10 or <=512 */
+	return stream_write_and_free(callback->plugin, callback->channel, out);
+
+fail:
+	Stream_Free(out, TRUE);
+	return ERROR_INTERNAL_ERROR;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT urbdrc_exchange_capabilities(GENERIC_CHANNEL_CALLBACK* callback, wStream* data)
+{
+	UINT32 MessageId = 0;
+	UINT32 FunctionId = 0;
+	UINT32 InterfaceId = 0;
+	UINT error = CHANNEL_RC_OK;
+
+	if (!data)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, data, 8))
+		return ERROR_INVALID_DATA;
+
+	Stream_Rewind_UINT32(data);
+	Stream_Read_UINT32(data, InterfaceId);
+	Stream_Read_UINT32(data, MessageId);
+	Stream_Read_UINT32(data, FunctionId);
+
+	switch (FunctionId)
+	{
+		case RIM_EXCHANGE_CAPABILITY_REQUEST:
+			error = urbdrc_process_capability_request(callback, data, MessageId);
+			break;
+
+		case RIMCALL_RELEASE:
+			break;
+
+		default:
+			error = ERROR_NOT_FOUND;
+			break;
+	}
+
+	return error;
+}
+
+static BOOL urbdrc_announce_devices(IUDEVMAN* udevman)
+{
+	UINT error = ERROR_SUCCESS;
+
+	udevman->loading_lock(udevman);
+	udevman->rewind(udevman);
+
+	while (udevman->has_next(udevman))
+	{
+		IUDEVICE* pdev = udevman->get_next(udevman);
+
+		if (!pdev->isAlreadySend(pdev))
+		{
+			const UINT32 deviceId = pdev->get_UsbDevice(pdev);
+			UINT cerror =
+			    urdbrc_send_virtual_channel_add(udevman->plugin, get_channel(udevman), deviceId);
+
+			if (cerror != ERROR_SUCCESS)
+				break;
+		}
+	}
+
+	udevman->loading_unlock(udevman);
+
+	return error == ERROR_SUCCESS;
+}
+
+static UINT urbdrc_device_control_channel(GENERIC_CHANNEL_CALLBACK* callback, wStream* s)
+{
+	URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+	IUDEVMAN* udevman = urbdrc->udevman;
+	IWTSVirtualChannel* channel = callback->channel;
+	IUDEVICE* pdev = NULL;
+	BOOL found = FALSE;
+	UINT error = ERROR_INTERNAL_ERROR;
+	UINT32 channelId = callback->channel_mgr->GetChannelId(channel);
+
+	switch (urbdrc->vchannel_status)
+	{
+		case INIT_CHANNEL_IN:
+			/* Control channel was established */
+			error = ERROR_SUCCESS;
+			udevman->initialize(udevman, channelId);
+
+			if (!urbdrc_announce_devices(udevman))
+				goto fail;
+
+			urbdrc->vchannel_status = INIT_CHANNEL_OUT;
+			break;
+
+		case INIT_CHANNEL_OUT:
+			/* A new device channel was created, add the channel
+			 * to the device */
+			udevman->loading_lock(udevman);
+			udevman->rewind(udevman);
+
+			while (udevman->has_next(udevman))
+			{
+				pdev = udevman->get_next(udevman);
+
+				if (!pdev->isAlreadySend(pdev))
+				{
+					const UINT32 channelID = callback->channel_mgr->GetChannelId(channel);
+					found = TRUE;
+					pdev->setAlreadySend(pdev);
+					pdev->set_channelManager(pdev, callback->channel_mgr);
+					pdev->set_channelID(pdev, channelID);
+					break;
+				}
+			}
+
+			udevman->loading_unlock(udevman);
+			error = ERROR_SUCCESS;
+
+			if (found && pdev->isAlreadySend(pdev))
+				error = urdbrc_send_usb_device_add(callback, pdev);
+
+			break;
+
+		default:
+			WLog_Print(urbdrc->log, WLOG_ERROR, "vchannel_status unknown value %" PRIu32 "",
+			           urbdrc->vchannel_status);
+			break;
+	}
+
+fail:
+	return error;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT urbdrc_process_channel_notification(GENERIC_CHANNEL_CALLBACK* callback, wStream* data)
+{
+	UINT32 MessageId = 0;
+	UINT32 FunctionId = 0;
+	UINT32 InterfaceId = 0;
+	UINT error = CHANNEL_RC_OK;
+	URBDRC_PLUGIN* urbdrc = NULL;
+
+	if (!callback || !data)
+		return ERROR_INVALID_PARAMETER;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (!urbdrc)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, data, 8))
+		return ERROR_INVALID_DATA;
+
+	Stream_Rewind(data, 4);
+	Stream_Read_UINT32(data, InterfaceId);
+	Stream_Read_UINT32(data, MessageId);
+	Stream_Read_UINT32(data, FunctionId);
+	WLog_Print(urbdrc->log, WLOG_TRACE, "%s [%" PRIu32 "]",
+	           call_to_string(FALSE, InterfaceId, FunctionId), FunctionId);
+
+	switch (FunctionId)
+	{
+		case CHANNEL_CREATED:
+			error = urbdrc_process_channel_create(callback, data, MessageId);
+			break;
+
+		case RIMCALL_RELEASE:
+			error = urbdrc_device_control_channel(callback, data);
+			break;
+
+		default:
+			WLog_Print(urbdrc->log, WLOG_TRACE, "unknown FunctionId 0x%" PRIX32 "", FunctionId);
+			error = 1;
+			break;
+	}
+
+	return error;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT urbdrc_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream* data)
+{
+	GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	IUDEVMAN* udevman = NULL;
+	UINT32 InterfaceId = 0;
+	UINT error = ERROR_INTERNAL_ERROR;
+
+	if (callback == NULL)
+		return ERROR_INVALID_PARAMETER;
+
+	if (callback->plugin == NULL)
+		return error;
+
+	urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+
+	if (urbdrc->udevman == NULL)
+		return error;
+
+	udevman = (IUDEVMAN*)urbdrc->udevman;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, data, 12))
+		return ERROR_INVALID_DATA;
+
+	urbdrc_dump_message(urbdrc->log, FALSE, FALSE, data);
+	Stream_Read_UINT32(data, InterfaceId);
+
+	/* Need to check InterfaceId and mask values */
+	switch (InterfaceId)
+	{
+		case CAPABILITIES_NEGOTIATOR | (STREAM_ID_NONE << 30):
+			error = urbdrc_exchange_capabilities(callback, data);
+			break;
+
+		case SERVER_CHANNEL_NOTIFICATION | (STREAM_ID_PROXY << 30):
+			error = urbdrc_process_channel_notification(callback, data);
+			break;
+
+		default:
+			error = urbdrc_process_udev_data_transfer(callback, urbdrc, udevman, data);
+			WLog_DBG(TAG, "urbdrc_process_udev_data_transfer returned 0x%08" PRIx32, error);
+			error = ERROR_SUCCESS; /* Ignore errors, the device may have been unplugged. */
+			break;
+	}
+
+	return error;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT urbdrc_on_close(IWTSVirtualChannelCallback* pChannelCallback)
+{
+	GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
+	if (callback)
+	{
+		URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*)callback->plugin;
+		if (urbdrc)
+		{
+			IUDEVMAN* udevman = urbdrc->udevman;
+			if (udevman && callback->channel_mgr)
+			{
+				UINT32 control = callback->channel_mgr->GetChannelId(callback->channel);
+				if (udevman->controlChannelId == control)
+					udevman->status |= URBDRC_DEVICE_CHANNEL_CLOSED;
+				else
+				{ /* Need to notify the local backend the device is gone */
+					IUDEVICE* pdev = udevman->get_udevice_by_ChannelID(udevman, control);
+					if (pdev)
+						pdev->markChannelClosed(pdev);
+				}
+			}
+		}
+	}
+	free(callback);
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT urbdrc_on_new_channel_connection(IWTSListenerCallback* pListenerCallback,
+                                             IWTSVirtualChannel* pChannel, BYTE* pData,
+                                             BOOL* pbAccept,
+                                             IWTSVirtualChannelCallback** ppCallback)
+{
+	GENERIC_LISTENER_CALLBACK* listener_callback = (GENERIC_LISTENER_CALLBACK*)pListenerCallback;
+	GENERIC_CHANNEL_CALLBACK* callback = NULL;
+
+	if (!ppCallback)
+		return ERROR_INVALID_PARAMETER;
+
+	callback = (GENERIC_CHANNEL_CALLBACK*)calloc(1, sizeof(GENERIC_CHANNEL_CALLBACK));
+
+	if (!callback)
+		return ERROR_OUTOFMEMORY;
+
+	callback->iface.OnDataReceived = urbdrc_on_data_received;
+	callback->iface.OnClose = urbdrc_on_close;
+	callback->plugin = listener_callback->plugin;
+	callback->channel_mgr = listener_callback->channel_mgr;
+	callback->channel = pChannel;
+	*ppCallback = (IWTSVirtualChannelCallback*)callback;
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT urbdrc_plugin_initialize(IWTSPlugin* pPlugin, IWTSVirtualChannelManager* pChannelMgr)
+{
+	UINT status = 0;
+	URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*)pPlugin;
+	IUDEVMAN* udevman = NULL;
+	char channelName[sizeof(URBDRC_CHANNEL_NAME)] = { URBDRC_CHANNEL_NAME };
+
+	if (!urbdrc || !urbdrc->udevman)
+		return ERROR_INVALID_PARAMETER;
+
+	if (urbdrc->initialized)
+	{
+		WLog_ERR(TAG, "[%s] channel initialized twice, aborting", URBDRC_CHANNEL_NAME);
+		return ERROR_INVALID_DATA;
+	}
+	udevman = urbdrc->udevman;
+	urbdrc->listener_callback =
+	    (GENERIC_LISTENER_CALLBACK*)calloc(1, sizeof(GENERIC_LISTENER_CALLBACK));
+
+	if (!urbdrc->listener_callback)
+		return CHANNEL_RC_NO_MEMORY;
+
+	urbdrc->listener_callback->iface.OnNewChannelConnection = urbdrc_on_new_channel_connection;
+	urbdrc->listener_callback->plugin = pPlugin;
+	urbdrc->listener_callback->channel_mgr = pChannelMgr;
+
+	/* [MS-RDPEUSB] 2.1 Transport defines the channel name in uppercase letters */
+	CharUpperA(channelName);
+	status = pChannelMgr->CreateListener(pChannelMgr, channelName, 0,
+	                                     &urbdrc->listener_callback->iface, &urbdrc->listener);
+	if (status != CHANNEL_RC_OK)
+		return status;
+
+	status = CHANNEL_RC_OK;
+	if (udevman->listener_created_callback)
+		status = udevman->listener_created_callback(udevman);
+
+	urbdrc->initialized = status == CHANNEL_RC_OK;
+	return status;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT urbdrc_plugin_terminated(IWTSPlugin* pPlugin)
+{
+	URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*)pPlugin;
+	IUDEVMAN* udevman = NULL;
+
+	if (!urbdrc)
+		return ERROR_INVALID_DATA;
+	if (urbdrc->listener_callback)
+	{
+		IWTSVirtualChannelManager* mgr = urbdrc->listener_callback->channel_mgr;
+		if (mgr)
+			IFCALL(mgr->DestroyListener, mgr, urbdrc->listener);
+	}
+	udevman = urbdrc->udevman;
+
+	if (udevman)
+	{
+		udevman->free(udevman);
+		udevman = NULL;
+	}
+
+	free(urbdrc->subsystem);
+	free(urbdrc->listener_callback);
+	free(urbdrc);
+	return CHANNEL_RC_OK;
+}
+
+static BOOL urbdrc_register_udevman_addin(IWTSPlugin* pPlugin, IUDEVMAN* udevman)
+{
+	URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*)pPlugin;
+
+	if (urbdrc->udevman)
+	{
+		WLog_Print(urbdrc->log, WLOG_ERROR, "existing device, abort.");
+		return FALSE;
+	}
+
+	DEBUG_DVC("device registered.");
+	urbdrc->udevman = udevman;
+	return TRUE;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT urbdrc_load_udevman_addin(IWTSPlugin* pPlugin, LPCSTR name, const ADDIN_ARGV* args)
+{
+	URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*)pPlugin;
+	PFREERDP_URBDRC_DEVICE_ENTRY entry = NULL;
+	FREERDP_URBDRC_SERVICE_ENTRY_POINTS entryPoints;
+	entry = (PFREERDP_URBDRC_DEVICE_ENTRY)freerdp_load_channel_addin_entry(URBDRC_CHANNEL_NAME,
+	                                                                       name, NULL, 0);
+
+	if (!entry)
+		return ERROR_INVALID_OPERATION;
+
+	entryPoints.plugin = pPlugin;
+	entryPoints.pRegisterUDEVMAN = urbdrc_register_udevman_addin;
+	entryPoints.args = args;
+
+	if (entry(&entryPoints) != 0)
+	{
+		WLog_Print(urbdrc->log, WLOG_ERROR, "%s entry returns error.", name);
+		return ERROR_INVALID_OPERATION;
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+static BOOL urbdrc_set_subsystem(URBDRC_PLUGIN* urbdrc, const char* subsystem)
+{
+	free(urbdrc->subsystem);
+	urbdrc->subsystem = _strdup(subsystem);
+	return (urbdrc->subsystem != NULL);
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT urbdrc_process_addin_args(URBDRC_PLUGIN* urbdrc, const ADDIN_ARGV* args)
+{
+	int status = 0;
+	COMMAND_LINE_ARGUMENT_A urbdrc_args[] = {
+		{ "dbg", COMMAND_LINE_VALUE_FLAG, "", NULL, BoolValueFalse, -1, NULL, "debug" },
+		{ "sys", COMMAND_LINE_VALUE_REQUIRED, "<subsystem>", NULL, NULL, -1, NULL, "subsystem" },
+		{ "dev", COMMAND_LINE_VALUE_REQUIRED, "<device list>", NULL, NULL, -1, NULL, "devices" },
+		{ "encode", COMMAND_LINE_VALUE_FLAG, "", NULL, NULL, -1, NULL, "encode" },
+		{ "quality", COMMAND_LINE_VALUE_REQUIRED, "<[0-2] -> [high-medium-low]>", NULL, NULL, -1,
+		  NULL, "quality" },
+		{ NULL, 0, NULL, NULL, NULL, -1, NULL, NULL }
+	};
+
+	const DWORD flags =
+	    COMMAND_LINE_SIGIL_NONE | COMMAND_LINE_SEPARATOR_COLON | COMMAND_LINE_IGN_UNKNOWN_KEYWORD;
+	const COMMAND_LINE_ARGUMENT_A* arg = NULL;
+	status =
+	    CommandLineParseArgumentsA(args->argc, args->argv, urbdrc_args, flags, urbdrc, NULL, NULL);
+
+	if (status < 0)
+		return ERROR_INVALID_DATA;
+
+	arg = urbdrc_args;
+
+	do
+	{
+		if (!(arg->Flags & COMMAND_LINE_VALUE_PRESENT))
+			continue;
+
+		CommandLineSwitchStart(arg) CommandLineSwitchCase(arg, "dbg")
+		{
+			WLog_SetLogLevel(urbdrc->log, WLOG_TRACE);
+		}
+		CommandLineSwitchCase(arg, "sys")
+		{
+			if (!urbdrc_set_subsystem(urbdrc, arg->Value))
+				return ERROR_OUTOFMEMORY;
+		}
+		CommandLineSwitchDefault(arg)
+		{
+		}
+		CommandLineSwitchEnd(arg)
+	} while ((arg = CommandLineFindNextArgumentA(arg)) != NULL);
+
+	return CHANNEL_RC_OK;
+}
+
+BOOL add_device(IUDEVMAN* idevman, UINT32 flags, BYTE busnum, BYTE devnum, UINT16 idVendor,
+                UINT16 idProduct)
+{
+	size_t success = 0;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	UINT32 mask = 0;
+	UINT32 regflags = 0;
+
+	if (!idevman)
+		return FALSE;
+
+	urbdrc = (URBDRC_PLUGIN*)idevman->plugin;
+
+	if (!urbdrc || !urbdrc->listener_callback)
+		return FALSE;
+
+	mask = (DEVICE_ADD_FLAG_VENDOR | DEVICE_ADD_FLAG_PRODUCT);
+	if ((flags & mask) == mask)
+		regflags |= UDEVMAN_FLAG_ADD_BY_VID_PID;
+	mask = (DEVICE_ADD_FLAG_BUS | DEVICE_ADD_FLAG_DEV);
+	if ((flags & mask) == mask)
+		regflags |= UDEVMAN_FLAG_ADD_BY_ADDR;
+
+	success = idevman->register_udevice(idevman, busnum, devnum, idVendor, idProduct, regflags);
+
+	if ((success > 0) && (flags & DEVICE_ADD_FLAG_REGISTER))
+	{
+		if (!urbdrc_announce_devices(idevman))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+BOOL del_device(IUDEVMAN* idevman, UINT32 flags, BYTE busnum, BYTE devnum, UINT16 idVendor,
+                UINT16 idProduct)
+{
+	IUDEVICE* pdev = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+
+	if (!idevman)
+		return FALSE;
+
+	urbdrc = (URBDRC_PLUGIN*)idevman->plugin;
+
+	if (!urbdrc || !urbdrc->listener_callback)
+		return FALSE;
+
+	idevman->loading_lock(idevman);
+	idevman->rewind(idevman);
+
+	while (idevman->has_next(idevman))
+	{
+		BOOL match = TRUE;
+		IUDEVICE* dev = idevman->get_next(idevman);
+
+		if ((flags & (DEVICE_ADD_FLAG_BUS | DEVICE_ADD_FLAG_DEV | DEVICE_ADD_FLAG_VENDOR |
+		              DEVICE_ADD_FLAG_PRODUCT)) == 0)
+			match = FALSE;
+		if (flags & DEVICE_ADD_FLAG_BUS)
+		{
+			if (dev->get_bus_number(dev) != busnum)
+				match = FALSE;
+		}
+		if (flags & DEVICE_ADD_FLAG_DEV)
+		{
+			if (dev->get_dev_number(dev) != devnum)
+				match = FALSE;
+		}
+		if (flags & DEVICE_ADD_FLAG_VENDOR)
+		{
+			int vid = dev->query_device_descriptor(dev, ID_VENDOR);
+			if (vid != idVendor)
+				match = FALSE;
+		}
+		if (flags & DEVICE_ADD_FLAG_PRODUCT)
+		{
+			int pid = dev->query_device_descriptor(dev, ID_PRODUCT);
+			if (pid != idProduct)
+				match = FALSE;
+		}
+
+		if (match)
+		{
+			pdev = dev;
+			break;
+		}
+	}
+
+	if (pdev)
+		pdev->setChannelClosed(pdev);
+
+	idevman->loading_unlock(idevman);
+	return TRUE;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+FREERDP_ENTRY_POINT(UINT urbdrc_DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints))
+{
+	UINT status = 0;
+	const ADDIN_ARGV* args = NULL;
+	URBDRC_PLUGIN* urbdrc = NULL;
+	urbdrc = (URBDRC_PLUGIN*)pEntryPoints->GetPlugin(pEntryPoints, URBDRC_CHANNEL_NAME);
+	args = pEntryPoints->GetPluginData(pEntryPoints);
+
+	if (urbdrc == NULL)
+	{
+		urbdrc = (URBDRC_PLUGIN*)calloc(1, sizeof(URBDRC_PLUGIN));
+
+		if (!urbdrc)
+			return CHANNEL_RC_NO_MEMORY;
+
+		urbdrc->iface.Initialize = urbdrc_plugin_initialize;
+		urbdrc->iface.Terminated = urbdrc_plugin_terminated;
+		urbdrc->vchannel_status = INIT_CHANNEL_IN;
+		status = pEntryPoints->RegisterPlugin(pEntryPoints, URBDRC_CHANNEL_NAME, &urbdrc->iface);
+
+		/* After we register the plugin free will be taken care of by dynamic channel */
+		if (status != CHANNEL_RC_OK)
+		{
+			free(urbdrc);
+			goto fail;
+		}
+
+		urbdrc->log = WLog_Get(TAG);
+
+		if (!urbdrc->log)
+			goto fail;
+	}
+
+	status = urbdrc_process_addin_args(urbdrc, args);
+
+	if (status != CHANNEL_RC_OK)
+		goto fail;
+
+	if (!urbdrc->subsystem && !urbdrc_set_subsystem(urbdrc, "libusb"))
+		goto fail;
+
+	return urbdrc_load_udevman_addin(&urbdrc->iface, urbdrc->subsystem, args);
+fail:
+	return status;
+}
+
+UINT stream_write_and_free(IWTSPlugin* plugin, IWTSVirtualChannel* channel, wStream* out)
+{
+	UINT rc = 0;
+	URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*)plugin;
+
+	if (!out)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!channel || !out || !urbdrc)
+	{
+		Stream_Free(out, TRUE);
+		return ERROR_INVALID_PARAMETER;
+	}
+
+	if (!channel->Write)
+	{
+		Stream_Free(out, TRUE);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	urbdrc_dump_message(urbdrc->log, TRUE, TRUE, out);
+	rc = channel->Write(channel, Stream_GetPosition(out), Stream_Buffer(out), NULL);
+	Stream_Free(out, TRUE);
+	return rc;
+}
diff --git a/channels/urbdrc/client/urbdrc_main.h b/channels/urbdrc/client/urbdrc_main.h
new file mode 100644
index 0000000..d13ed95
--- /dev/null
+++ b/channels/urbdrc/client/urbdrc_main.h
@@ -0,0 +1,222 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX USB Redirection
+ *
+ * Copyright 2012 Atrust corp.
+ * Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_CHANNEL_URBDRC_CLIENT_MAIN_H
+#define FREERDP_CHANNEL_URBDRC_CLIENT_MAIN_H
+
+#include <winpr/pool.h>
+#include <freerdp/channels/log.h>
+#include <freerdp/client/channels.h>
+
+#define DEVICE_HARDWARE_ID_SIZE 32
+#define DEVICE_COMPATIBILITY_ID_SIZE 36
+#define DEVICE_INSTANCE_STR_SIZE 37
+#define DEVICE_CONTAINER_STR_SIZE 39
+
+#define TAG CHANNELS_TAG("urbdrc.client")
+#ifdef WITH_DEBUG_DVC
+#define DEBUG_DVC(...) WLog_DBG(TAG, __VA_ARGS__)
+#else
+#define DEBUG_DVC(...) \
+	do                 \
+	{                  \
+	} while (0)
+#endif
+
+typedef struct S_IUDEVICE IUDEVICE;
+typedef struct S_IUDEVMAN IUDEVMAN;
+
+#define BASIC_DEV_STATE_DEFINED(_arg, _type) \
+	_type (*get_##_arg)(IUDEVICE * pdev);    \
+	void (*set_##_arg)(IUDEVICE * pdev, _type _arg)
+
+#define BASIC_DEVMAN_STATE_DEFINED(_arg, _type) \
+	_type (*get_##_arg)(IUDEVMAN * udevman);    \
+	void (*set_##_arg)(IUDEVMAN * udevman, _type _arg)
+
+typedef struct
+{
+	IWTSPlugin iface;
+
+	GENERIC_LISTENER_CALLBACK* listener_callback;
+
+	IUDEVMAN* udevman;
+	UINT32 vchannel_status;
+	char* subsystem;
+
+	wLog* log;
+	IWTSListener* listener;
+	BOOL initialized;
+} URBDRC_PLUGIN;
+
+typedef BOOL (*PREGISTERURBDRCSERVICE)(IWTSPlugin* plugin, IUDEVMAN* udevman);
+typedef struct
+{
+	IWTSPlugin* plugin;
+	PREGISTERURBDRCSERVICE pRegisterUDEVMAN;
+	const ADDIN_ARGV* args;
+} FREERDP_URBDRC_SERVICE_ENTRY_POINTS;
+typedef FREERDP_URBDRC_SERVICE_ENTRY_POINTS* PFREERDP_URBDRC_SERVICE_ENTRY_POINTS;
+
+typedef int (*PFREERDP_URBDRC_DEVICE_ENTRY)(PFREERDP_URBDRC_SERVICE_ENTRY_POINTS pEntryPoints);
+
+typedef struct
+{
+	GENERIC_CHANNEL_CALLBACK* callback;
+	URBDRC_PLUGIN* urbdrc;
+	IUDEVMAN* udevman;
+	IWTSVirtualChannel* channel;
+	wStream* s;
+} TRANSFER_DATA;
+
+typedef void (*t_isoch_transfer_cb)(IUDEVICE* idev, GENERIC_CHANNEL_CALLBACK* callback,
+                                    wStream* out, UINT32 InterfaceId, BOOL noAck, UINT32 MessageId,
+                                    UINT32 RequestId, UINT32 NumberOfPackets, UINT32 status,
+                                    UINT32 StartFrame, UINT32 ErrorCount, UINT32 OutputBufferSize);
+
+struct S_IUDEVICE
+{
+	/* Transfer */
+	int (*isoch_transfer)(IUDEVICE* idev, GENERIC_CHANNEL_CALLBACK* callback, UINT32 MessageId,
+	                      UINT32 RequestId, UINT32 EndpointAddress, UINT32 TransferFlags,
+	                      UINT32 StartFrame, UINT32 ErrorCount, BOOL NoAck,
+	                      const BYTE* packetDescriptorData, UINT32 NumberOfPackets,
+	                      UINT32 BufferSize, const BYTE* Buffer, t_isoch_transfer_cb cb,
+	                      UINT32 Timeout);
+
+	BOOL(*control_transfer)
+	(IUDEVICE* idev, UINT32 RequestId, UINT32 EndpointAddress, UINT32 TransferFlags,
+	 BYTE bmRequestType, BYTE Request, UINT16 Value, UINT16 Index, UINT32* UrbdStatus,
+	 UINT32* BufferSize, BYTE* Buffer, UINT32 Timeout);
+
+	int (*bulk_or_interrupt_transfer)(IUDEVICE* idev, GENERIC_CHANNEL_CALLBACK* callback,
+	                                  UINT32 MessageId, UINT32 RequestId, UINT32 EndpointAddress,
+	                                  UINT32 TransferFlags, BOOL NoAck, UINT32 BufferSize,
+	                                  const BYTE* data, t_isoch_transfer_cb cb, UINT32 Timeout);
+
+	int (*select_configuration)(IUDEVICE* idev, UINT32 bConfigurationValue);
+
+	int (*select_interface)(IUDEVICE* idev, BYTE InterfaceNumber, BYTE AlternateSetting);
+
+	int (*control_pipe_request)(IUDEVICE* idev, UINT32 RequestId, UINT32 EndpointAddress,
+	                            UINT32* UsbdStatus, int command);
+
+	UINT32(*control_query_device_text)
+	(IUDEVICE* idev, UINT32 TextType, UINT16 LocaleId, UINT8* BufferSize, BYTE* Buffer);
+
+	int (*os_feature_descriptor_request)(IUDEVICE* idev, UINT32 RequestId, BYTE Recipient,
+	                                     BYTE InterfaceNumber, BYTE Ms_PageIndex,
+	                                     UINT16 Ms_featureDescIndex, UINT32* UsbdStatus,
+	                                     UINT32* BufferSize, BYTE* Buffer, UINT32 Timeout);
+
+	void (*cancel_all_transfer_request)(IUDEVICE* idev);
+
+	int (*cancel_transfer_request)(IUDEVICE* idev, UINT32 RequestId);
+
+	int (*query_device_descriptor)(IUDEVICE* idev, int offset);
+
+	BOOL (*detach_kernel_driver)(IUDEVICE* idev);
+
+	BOOL (*attach_kernel_driver)(IUDEVICE* idev);
+
+	int (*query_device_port_status)(IUDEVICE* idev, UINT32* UsbdStatus, UINT32* BufferSize,
+	                                BYTE* Buffer);
+
+	MSUSB_CONFIG_DESCRIPTOR* (*complete_msconfig_setup)(IUDEVICE* idev,
+	                                                    MSUSB_CONFIG_DESCRIPTOR* MsConfig);
+	/* Basic state */
+	int (*isCompositeDevice)(IUDEVICE* idev);
+
+	int (*isExist)(IUDEVICE* idev);
+	int (*isAlreadySend)(IUDEVICE* idev);
+	int (*isChannelClosed)(IUDEVICE* idev);
+
+	void (*setAlreadySend)(IUDEVICE* idev);
+	void (*setChannelClosed)(IUDEVICE* idev);
+	void (*markChannelClosed)(IUDEVICE* idev);
+	char* (*getPath)(IUDEVICE* idev);
+
+	void (*free)(IUDEVICE* idev);
+
+	BASIC_DEV_STATE_DEFINED(channelManager, IWTSVirtualChannelManager*);
+	BASIC_DEV_STATE_DEFINED(channelID, UINT32);
+	BASIC_DEV_STATE_DEFINED(UsbDevice, UINT32);
+	BASIC_DEV_STATE_DEFINED(ReqCompletion, UINT32);
+	BASIC_DEV_STATE_DEFINED(bus_number, BYTE);
+	BASIC_DEV_STATE_DEFINED(dev_number, BYTE);
+	BASIC_DEV_STATE_DEFINED(port_number, int);
+	BASIC_DEV_STATE_DEFINED(MsConfig, MSUSB_CONFIG_DESCRIPTOR*);
+
+	BASIC_DEV_STATE_DEFINED(p_udev, void*);
+	BASIC_DEV_STATE_DEFINED(p_prev, void*);
+	BASIC_DEV_STATE_DEFINED(p_next, void*);
+};
+
+struct S_IUDEVMAN
+{
+	/* Standard */
+	void (*free)(IUDEVMAN* idevman);
+
+	/* Manage devices */
+	void (*rewind)(IUDEVMAN* idevman);
+	BOOL (*has_next)(IUDEVMAN* idevman);
+	BOOL (*unregister_udevice)(IUDEVMAN* idevman, BYTE bus_number, BYTE dev_number);
+	size_t (*register_udevice)(IUDEVMAN* idevman, BYTE bus_number, BYTE dev_number, UINT16 idVendor,
+	                           UINT16 idProduct, UINT32 flag);
+	IUDEVICE* (*get_next)(IUDEVMAN* idevman);
+	IUDEVICE* (*get_udevice_by_UsbDevice)(IUDEVMAN* idevman, UINT32 UsbDevice);
+	IUDEVICE* (*get_udevice_by_ChannelID)(IUDEVMAN* idevman, UINT32 channelID);
+
+	/* Extension */
+	int (*isAutoAdd)(IUDEVMAN* idevman);
+
+	/* Basic state */
+	BASIC_DEVMAN_STATE_DEFINED(device_num, UINT32);
+	BASIC_DEVMAN_STATE_DEFINED(next_device_id, UINT32);
+
+	/* control semaphore or mutex lock */
+	void (*loading_lock)(IUDEVMAN* idevman);
+	void (*loading_unlock)(IUDEVMAN* idevman);
+	BOOL (*initialize)(IUDEVMAN* idevman, UINT32 channelId);
+	UINT (*listener_created_callback)(IUDEVMAN* idevman);
+
+	IWTSPlugin* plugin;
+	UINT32 controlChannelId;
+	UINT32 status;
+};
+
+#define DEVICE_ADD_FLAG_BUS 0x01
+#define DEVICE_ADD_FLAG_DEV 0x02
+#define DEVICE_ADD_FLAG_VENDOR 0x04
+#define DEVICE_ADD_FLAG_PRODUCT 0x08
+#define DEVICE_ADD_FLAG_REGISTER 0x10
+
+#define DEVICE_ADD_FLAG_ALL                                               \
+	(DEVICE_ADD_FLAG_BUS | DEVICE_ADD_FLAG_DEV | DEVICE_ADD_FLAG_VENDOR | \
+	 DEVICE_ADD_FLAG_PRODUCT | DEVICE_ADD_FLAG_REGISTER)
+
+FREERDP_API BOOL add_device(IUDEVMAN* idevman, UINT32 flags, BYTE busnum, BYTE devnum,
+                            UINT16 idVendor, UINT16 idProduct);
+FREERDP_API BOOL del_device(IUDEVMAN* idevman, UINT32 flags, BYTE busnum, BYTE devnum,
+                            UINT16 idVendor, UINT16 idProduct);
+
+UINT stream_write_and_free(IWTSPlugin* plugin, IWTSVirtualChannel* channel, wStream* s);
+
+#endif /* FREERDP_CHANNEL_URBDRC_CLIENT_MAIN_H */