improve device support (#19)

- add error conversion (VBox -> Linux)
- add STALL recovery
- add USB 3 support
- add alternate interface support
- fix reported device speed

Author: dorssel

Directory.Packages.props

@@ -7,7 +7,7 @@ SPDX-License-Identifier: GPL-2.0-only
 <Project>
   <ItemGroup>
     <!-- all -->
-    <PackageVersion Include="GitVersion.MsBuild" Version="5.6.8" />
+    <PackageVersion Include="GitVersion.MsBuild" Version="5.6.9" />
 
     <!-- UsbIpServer -->
     <PackageVersion Include="Microsoft.Extensions.CommandLineUtils" Version="1.1.1" />

UsbIpServer/AttachedClient.cs

@@ -49,13 +49,16 @@ async Task HandleSubmitAsync(UsbIpHeaderBasic basic, UsbIpHeaderCmdSubmit submit
             {
                 ep = basic.ep,
                 dir = (basic.direction == UsbIpDir.USBIP_DIR_IN) ? UsbSupDirection.USBSUP_DIRECTION_IN : UsbSupDirection.USBSUP_DIRECTION_OUT,
-                flags = (basic.direction == UsbIpDir.USBIP_DIR_IN) ? UsbSupXferFlags.USBSUP_FLAG_SHORT_OK : UsbSupXferFlags.USBSUP_FLAG_NONE,
+                flags = (basic.direction == UsbIpDir.USBIP_DIR_IN)
+                    ? (((submit.transfer_flags & 1) != 0) ? UsbSupXferFlags.USBSUP_FLAG_NONE : UsbSupXferFlags.USBSUP_FLAG_SHORT_OK)
+                    : UsbSupXferFlags.USBSUP_FLAG_NONE,
                 error = UsbSupError.USBSUP_XFER_OK,
                 len = submit.transfer_buffer_length,
                 numIsoPkts = (uint)submit.number_of_packets,
                 aIsoPkts = new UsbSupIsoPkt[8],
             };
 
+            var requestLength = submit.transfer_buffer_length;
             var payloadOffset = 0;
             switch (transferType)
             {
@@ -95,17 +98,52 @@ async Task HandleSubmitAsync(UsbIpHeaderBasic basic, UsbIpHeaderCmdSubmit submit
                 throw new NotImplementedException("ISO transfers");
             }
 
-            if ((basic.ep == 0) && (submit.setup.bmRequestType == 0) && (submit.setup.bRequest == UsbRequest.SET_CONFIGURATION))
+            if ((basic.ep == 0)
+                && (submit.setup.bmRequestType == UsbRequestTypeRecipient.DEVICE)
+                && (submit.setup.bRequest == UsbRequest.SET_CONFIGURATION))
             {
                 // VBoxUsb needs this to get the endpoint handles
-                var configurationValue = (byte)submit.setup.wValue;
-                Logger.LogTrace($"Trapped SET_CONFIGURATION {configurationValue}");
-                await Device.IoControlAsync(IoControl.SUPUSB_IOCTL_USB_SET_CONFIG, new byte[] { configurationValue }, null);
-                ConfigurationDescriptors.SetConfiguration(configurationValue);
+                var setConfig = new UsbSupSetConfig()
+                {
+                    bConfigurationValue = (byte)submit.setup.wValue,
+                };
+                Logger.LogDebug($"Trapped SET_CONFIGURATION: {setConfig.bConfigurationValue}");
+                await Device.IoControlAsync(IoControl.SUPUSB_IOCTL_USB_SET_CONFIG, StructToBytes(setConfig), null);
+                ConfigurationDescriptors.SetConfiguration(setConfig.bConfigurationValue);
+            }
+            else if ((basic.ep == 0)
+                && (submit.setup.bmRequestType == UsbRequestTypeRecipient.DEVICE)
+                && (submit.setup.bRequest == UsbRequest.SET_INTERFACE))
+            {
+                // VBoxUsb needs this to get the endpoint handles
+                var selectInterface = new UsbSupSelectInterface()
+                {
+                    bInterfaceNumber = (byte)submit.setup.wIndex,
+                    bAlternateSetting = (byte)submit.setup.wValue,
+                };
+                Logger.LogDebug($"Trapped SET_INTERFACE: {selectInterface.bInterfaceNumber} -> {selectInterface.bAlternateSetting}");
+                await Device.IoControlAsync(IoControl.SUPUSB_IOCTL_USB_SELECT_INTERFACE, StructToBytes(selectInterface), null);
+                ConfigurationDescriptors.SetInterface(selectInterface.bInterfaceNumber, selectInterface.bAlternateSetting);
+            }
+            else if ((basic.ep == 0)
+                && (submit.setup.bmRequestType == UsbRequestTypeRecipient.ENDPOINT)
+                && (submit.setup.bRequest == UsbRequest.CLEAR_FEATURE)
+                && (submit.setup.wValue == 0))
+            {
+                // VBoxUsb needs this to notify the host controller
+                var clearEndpoint = new UsbSupClearEndpoint()
+                {
+                    bEndpoint = (byte)submit.setup.wIndex,
+                };
+                Logger.LogDebug($"Trapped CLEAR_FEATURE: {clearEndpoint.bEndpoint}");
+                await Device.IoControlAsync(IoControl.SUPUSB_IOCTL_USB_CLEAR_ENDPOINT, StructToBytes(clearEndpoint), null);
             }
             else
             {
-                Logger.LogTrace($"{submit.setup.bmRequestType} {submit.setup.bRequest} {submit.setup.wValue} {submit.setup.wIndex} {submit.setup.wLength}");
+                if (transferType == UsbEndpointType.USB_ENDPOINT_TYPE_CONTROL)
+                {
+                    Logger.LogTrace($"{submit.setup.bmRequestType} {submit.setup.bRequest} {submit.setup.wValue} {submit.setup.wIndex} {submit.setup.wLength}");
+                }
                 var gc = GCHandle.Alloc(buf, GCHandleType.Pinned);
                 try
                 {
@@ -123,7 +161,7 @@ async Task HandleSubmitAsync(UsbIpHeaderBasic basic, UsbIpHeaderCmdSubmit submit
             basic.command = UsbIpCmd.USBIP_RET_SUBMIT;
             var retSubmit = new UsbIpHeaderRetSubmit()
             {
-                status = (int)urb.error,
+                status = -(int)ConvertError(urb.error),
                 actual_length = (int)urb.len,
                 start_frame = submit.start_frame,
                 number_of_packets = (int)urb.numIsoPkts,
@@ -135,7 +173,12 @@ async Task HandleSubmitAsync(UsbIpHeaderBasic basic, UsbIpHeaderCmdSubmit submit
                 retSubmit.actual_length = (retSubmit.actual_length > payloadOffset) ? (retSubmit.actual_length - payloadOffset) : 0;
             }
 
-            Logger.LogTrace($"actual: {retSubmit.actual_length}");
+            if (urb.error != UsbSupError.USBSUP_XFER_OK)
+            {
+                Logger.LogDebug($"{urb.error} -> {ConvertError(urb.error)} -> {retSubmit.status}");
+            }
+            Logger.LogTrace($"actual: {retSubmit.actual_length}, requested: {requestLength}");
+
             var retBuf = new byte[48 /* sizeof(usbip_header) */];
             BinaryPrimitives.WriteUInt32BigEndian(retBuf.AsSpan(0), (uint)basic.command);
             BinaryPrimitives.WriteUInt32BigEndian(retBuf.AsSpan(4), basic.seqnum);

UsbIpServer/ExportedDevice.cs

@@ -183,12 +183,36 @@ public static async Task<ExportedDevice[]> GetAll(CancellationToken cancellation
                     await hubFile.IoControlAsync(IoControl.IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX, buf, buf);
                     BytesToStruct(buf, 0, out data);
 
+                    var speed = MapWindowsSpeedToLinuxSpeed(data.Speed);
+
+                    var data2 = new UsbNodeConnectionInformationExV2()
+                    {
+                        ConnectionIndex = connectionIndex,
+                        Length = (uint)Marshal.SizeOf<UsbNodeConnectionInformationExV2>(),
+                        SupportedUsbProtocols = UsbProtocols.Usb110 | UsbProtocols.Usb200 | UsbProtocols.Usb300,
+                    };
+                    var buf2 = StructToBytes(data2);
+                    await hubFile.IoControlAsync(IoControl.IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX_V2, buf2, buf2);
+                    BytesToStruct(buf2, 0, out data2);
+
+                    if ((data2.SupportedUsbProtocols & UsbProtocols.Usb300) != 0)
+                    {
+                        if ((data2.Flags & UsbNodeConnectionInformationExV2Flags.DeviceIsOperatingAtSuperSpeedPlusOrHigher) != 0)
+                        {
+                            speed = Linux.UsbDeviceSpeed.USB_SPEED_SUPER_PLUS;
+                        }
+                        else if ((data2.Flags & UsbNodeConnectionInformationExV2Flags.DeviceIsOperatingAtSuperSpeedOrHigher) != 0)
+                        {
+                            speed = Linux.UsbDeviceSpeed.USB_SPEED_SUPER;
+                        }
+                    }
+
                     var exportedDevice = new ExportedDevice()
                     {
                         Path = instanceId,
                         BusNum = hubNum,
                         DevNum = connectionIndex,
-                        Speed = MapWindowsSpeedToLinuxSpeed(data.Speed),
+                        Speed = speed,
                         VendorId = data.DeviceDescriptor.idVendor,
                         ProductId = data.DeviceDescriptor.idProduct,
                         BcdDevice = data.DeviceDescriptor.bcdDevice,

UsbIpServer/Interop/Linux.cs

@@ -17,5 +17,22 @@ public enum UsbDeviceSpeed : uint
             USB_SPEED_SUPER,               // usb 3.0
             USB_SPEED_SUPER_PLUS,          // usb 3.1
         }
+
+        public enum Errno : int
+        {
+            SUCCESS = 0,
+            /// <summary>linux: errno-base.h</summary>
+            EPIPE = 32,
+            /// <summary>linux: errno.h</summary>
+            ETIME = 62,
+            /// <summary>linux: errno.h</summary>
+            EPROTO = 71,
+            /// <summary>linux: errno.h</summary>
+            EOVERFLOW = 75,
+            /// <summary>linux: errno.h</summary>
+            EILSEQ = 84,
+            /// <summary>linux: errno.h</summary>
+            EREMOTEIO = 121,
+        }
     }
 }

UsbIpServer/Interop/Usb.cs

@@ -91,8 +91,22 @@ public struct UsbEndpointDescriptor
             public byte bInterval;
         }
 
+        public enum UsbRequestTypeRecipient : byte
+        {
+            /// <summary>WinSDK: usbspec.h: BMREQUEST_TO_DEVICE</summary>
+            DEVICE = 0,
+            /// <summary>WinSDK: usbspec.h: BMREQUEST_TO_INTERFACE</summary>
+            INTERFACE,
+            /// <summary>WinSDK: usbspec.h: BMREQUEST_TO_ENDPOINT</summary>
+            ENDPOINT,
+            /// <summary>WinSDK: usbspec.h: BMREQUEST_TO_OTHER</summary>
+            OTHER,
+        }
+
         public enum UsbRequest : byte
         {
+            /// <summary>WinSDK: usbspec.h: USB_REQUEST_SET_CONFIGURATION</summary>
+            CLEAR_FEATURE = 0x01,
             /// <summary>WinSDK: usbspec.h: USB_REQUEST_SET_CONFIGURATION</summary>
             SET_CONFIGURATION = 0x09,
             /// <summary>WinSDK: usbspec.h: USB_REQUEST_SET_INTERFACE</summary>
@@ -103,7 +117,7 @@ public enum UsbRequest : byte
         [StructLayout(LayoutKind.Sequential, Pack = 1)]
         public struct UsbDefaultPipeSetupPacket
         {
-            public byte bmRequestType;
+            public UsbRequestTypeRecipient bmRequestType;
             public UsbRequest bRequest;
             public ushort wValue;
             public ushort wIndex;

UsbIpServer/Interop/VBoxUsb.cs

@@ -177,6 +177,8 @@ public enum IoControl : uint
             /// <summary>VBoxUsb: usblib-win.h</summary>
             SUPUSB_IOCTL_USB_RESET = (DeviceType.FILE_DEVICE_UNKNOWN << 16) | (AccessCode.FILE_WRITE_ACCESS << 14) | (0x608 << 2) | (MethodCode.METHOD_BUFFERED),
             /// <summary>VBoxUsb: usblib-win.h</summary>
+            SUPUSB_IOCTL_USB_SELECT_INTERFACE = (DeviceType.FILE_DEVICE_UNKNOWN << 16) | (AccessCode.FILE_WRITE_ACCESS << 14) | (0x609 << 2) | (MethodCode.METHOD_BUFFERED),
+            /// <summary>VBoxUsb: usblib-win.h</summary>
             SUPUSB_IOCTL_USB_SET_CONFIG = (DeviceType.FILE_DEVICE_UNKNOWN << 16) | (AccessCode.FILE_WRITE_ACCESS << 14) | (0x60a << 2) | (MethodCode.METHOD_BUFFERED),
             /// <summary>VBoxUsb: usblib-win.h</summary>
             SUPUSB_IOCTL_USB_CLAIM_DEVICE = (DeviceType.FILE_DEVICE_UNKNOWN << 16) | (AccessCode.FILE_WRITE_ACCESS << 14) | (0x60b << 2) | (MethodCode.METHOD_BUFFERED),
@@ -185,6 +187,8 @@ public enum IoControl : uint
             /// <summary>VBoxUsb: usblib-win.h</summary>
             SUPUSB_IOCTL_IS_OPERATIONAL = (DeviceType.FILE_DEVICE_UNKNOWN << 16) | (AccessCode.FILE_WRITE_ACCESS << 14) | (0x60d << 2) | (MethodCode.METHOD_BUFFERED),
             /// <summary>VBoxUsb: usblib-win.h</summary>
+            SUPUSB_IOCTL_USB_CLEAR_ENDPOINT = (DeviceType.FILE_DEVICE_UNKNOWN << 16) | (AccessCode.FILE_WRITE_ACCESS << 14) | (0x60e << 2) | (MethodCode.METHOD_BUFFERED),
+            /// <summary>VBoxUsb: usblib-win.h</summary>
             SUPUSB_IOCTL_GET_VERSION = (DeviceType.FILE_DEVICE_UNKNOWN << 16) | (AccessCode.FILE_WRITE_ACCESS << 14) | (0x60f << 2) | (MethodCode.METHOD_BUFFERED),
         }
 
@@ -267,5 +271,27 @@ public struct UsbSupUrb
             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
             public UsbSupIsoPkt[] aIsoPkts;    /* [in/out] isochronous packet descriptors */
         }
+
+        /// <summary>VBoxUsb: usblib-win.h: USBSUP_SET_CONFIG</summary>
+        [StructLayout(LayoutKind.Sequential, Pack = 1)]
+        public struct UsbSupSetConfig
+        {
+            public byte bConfigurationValue;
+        }
+
+        /// <summary>VBoxUsb: usblib-win.h: USBSUP_SELECT_INTERFACE</summary>
+        [StructLayout(LayoutKind.Sequential, Pack = 1)]
+        public struct UsbSupSelectInterface
+        {
+            public byte bInterfaceNumber;
+            public byte bAlternateSetting;
+        }
+
+        /// <summary>VBoxUsb: usblib-win.h: USBSUP_CLEAR_ENDPOINT</summary>
+        [StructLayout(LayoutKind.Sequential, Pack = 1)]
+        public struct UsbSupClearEndpoint
+        {
+            public byte bEndpoint;
+        }
     }
 }

UsbIpServer/Interop/WinSDK.cs

@@ -190,9 +190,10 @@ public enum FunctionCode : ushort
         {
             /// <summary>WinSDK: usbiodef.h</summary>
             USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION = 260,
-
             /// <summary>WinSDK: usbiodef.h</summary>
             USB_GET_NODE_CONNECTION_INFORMATION_EX = 274,
+            /// <summary>WinSDK: usbiodef.h</summary>
+            USB_GET_NODE_CONNECTION_INFORMATION_EX_V2 = 279,
         }
 
         public enum MethodCode : byte
@@ -218,6 +219,9 @@ public enum IoControl : uint
             /// <summary>WinSDK: usbioctl.h</summary>
             IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX = (DeviceType.FILE_DEVICE_USB << 16) | (AccessCode.FILE_ANY_ACCESS << 14)
                 | (FunctionCode.USB_GET_NODE_CONNECTION_INFORMATION_EX << 2) | (MethodCode.METHOD_BUFFERED),
+
+            IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX_V2 = (DeviceType.FILE_DEVICE_USB << 16) | (AccessCode.FILE_ANY_ACCESS << 14)
+                | (FunctionCode.USB_GET_NODE_CONNECTION_INFORMATION_EX_V2 << 2) | (MethodCode.METHOD_BUFFERED),
         }
 
         /// <summary>WinSDK: usbioctl.h: USB_DESCRIPTOR_REQUEST</summary>
@@ -262,5 +266,35 @@ public struct UsbNodeConnectionInformationEx
             public uint ConnectionStatus;
             /* USB_PIPE_INFO PipeList[0]; */
         }
+
+        /// <summary>WinSDK: usbioctl.h: USB_PROTOCOLS</summary>
+        [Flags]
+        public enum UsbProtocols : uint
+        {
+            None = 0,
+            Usb110 = (1 << 0),
+            Usb200 = (1 << 1),
+            Usb300 = (1 << 2),
+        }
+
+        /// <summary>WinSDK: usbioctl.h: USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS</summary>
+        [Flags]
+        public enum UsbNodeConnectionInformationExV2Flags : uint
+        {
+            DeviceIsOperatingAtSuperSpeedOrHigher = (1 << 0),
+            DeviceIsSuperSpeedCapableOrHigher = (1 << 1),
+            DeviceIsOperatingAtSuperSpeedPlusOrHigher = (1 << 2),
+            DeviceIsSuperSpeedPlusCapableOrHigher = (1 << 3),
+        }
+
+        /// <summary>WinSDK: usbioctl.h: USB_NODE_CONNECTION_INFORMATION_EX_V2</summary>
+        [StructLayout(LayoutKind.Sequential, Pack = 1)]
+        public struct UsbNodeConnectionInformationExV2
+        {
+            public uint ConnectionIndex;
+            public uint Length;
+            public UsbProtocols SupportedUsbProtocols;
+            public UsbNodeConnectionInformationExV2Flags Flags;
+        }
     }
 }

UsbIpServer/Tools.cs

@@ -268,5 +268,23 @@ public static void GetBusId(SafeDeviceInfoSetHandle deviceInfoSet, in SpDevInfoD
                 throw new NotSupportedException($"DEVPKEY_Device_LocationInfo returned unexpected {nameof(connectionIndex)} 0");
             }
         }
+
+        /// <summary>
+        /// See <see href="https://www.kernel.org/doc/html/latest/driver-api/usb/error-codes.html"/>.
+        /// </summary>
+        public static Linux.Errno ConvertError(VBoxUsb.UsbSupError usbSupError)
+        {
+            return usbSupError switch
+            {
+                VBoxUsb.UsbSupError.USBSUP_XFER_OK => Linux.Errno.SUCCESS,
+                VBoxUsb.UsbSupError.USBSUP_XFER_STALL => Linux.Errno.EPIPE,
+                VBoxUsb.UsbSupError.USBSUP_XFER_DNR => Linux.Errno.ETIME,
+                VBoxUsb.UsbSupError.USBSUP_XFER_CRC => Linux.Errno.EILSEQ,
+                VBoxUsb.UsbSupError.USBSUP_XFER_NAC => Linux.Errno.EPROTO,
+                VBoxUsb.UsbSupError.USBSUP_XFER_UNDERRUN => Linux.Errno.EREMOTEIO,
+                VBoxUsb.UsbSupError.USBSUP_XFER_OVERRUN => Linux.Errno.EOVERFLOW,
+                _ => Linux.Errno.EPROTO,
+            };
+        }
     }
 }