Changeset 31247 in vbox for trunk

Timestamp:

Jul 30, 2010 1:37:49 PM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

64261

Message:

RDP/client: updates to the RDP client code

Location:

trunk/src/VBox/RDP/client/vrdp

Files:

• USBProxyDevice-linux.c (modified) (63 diffs)
• USBProxyDevice.h (added)
• rdpusb.c (modified) (20 diffs)
• runtime.h (copied) (copied from trunk/src/VBox/RDP/client/vrdp/vrdpusb.h ) (6 diffs)
• vrdpusb.h (modified) (2 diffs)
• vusb.h (modified) (15 diffs)

trunk/src/VBox/RDP/client/vrdp/USBProxyDevice-linux.c

@@ +1 @@
+/* $Id$ */
 /** @file
- *
- * VUSB Device - USB Device Proxy, the Linux backend.
+ * USB device proxy - the Linux backend.
  */
 
@@ -7 +7 @@
  * Copyright (C) 2006-2007 Oracle Corporation
  *
- * This file is part of VirtualBox Open Source Edition (OSE), as
- * available from http://www.virtualbox.org. This file is free software;
- * you can redistribute it and/or modify it under the terms of the GNU
- * General Public License (GPL) as published by the Free Software
- * Foundation, in version 2 as it comes in the "COPYING" file of the
- * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ * Oracle Corporation confidential
+ * All rights reserved
  */
 
@@ -31 +26 @@
 *******************************************************************************/
 #define LOG_GROUP LOG_GROUP_DRV_USBPROXY
-#if defined(VBOX) && !defined(RDESKTOP)
+#ifndef RDESKTOP
 # include <iprt/stdint.h>
 #endif
@@ -47 +42 @@
 #include <fcntl.h>
 #include <errno.h>
-#include <ctype.h>
 #ifdef VBOX_WITH_LINUX_COMPILER_H
 # include <linux/compiler.h>
@@ -71 +65 @@
 #endif
 
-#if defined(VBOX) && !defined(RDESKTOP)
+#ifndef RDESKTOP
 # include <VBox/pdm.h>
 # include <VBox/err.h>
 # include <VBox/log.h>
+# include <iprt/alloc.h>
 # include <iprt/assert.h>
+# include <iprt/asm.h>
+# include <iprt/ctype.h>
+# include <iprt/file.h>
+# include <iprt/linux/sysfs.h>
 # include <iprt/stream.h>
-# include <iprt/alloc.h>
+# include <iprt/string.h>
 # include <iprt/thread.h>
 # include <iprt/time.h>
-# include <iprt/asm.h>
-# include <iprt/string.h>
-# include <iprt/file.h>
 # include "../USBProxyDevice.h"
 #else
 
 # include "../rdesktop.h"
-# include "vrdpusb.h"
+# include "runtime.h"
+# include "USBProxyDevice.h"
+# ifdef VBOX_USB_WITH_SYSFS
+#  include "sysfs.h"
+# endif
 #endif
 
@@ -102 +102 @@
     /** The kernel URB data */
     struct usbdevfs_urb     KUrb;
+    /** Space filler for the isochronous packets. */
+    struct usbdevfs_iso_packet_desc aIsocPktsDonUseTheseUseTheOnesInKUrb[8];
     /** The millisecond timestamp when this URB was submitted. */
     uint64_t                u64SubmitTS;
@@ -120 +122 @@
     /** This split element is reaped. */
     bool                    fSplitElementReaped;
+    /** Size to transfer in remaining fragments of a split URB */
+    uint32_t                cbSplitRemaining;
 } USBPROXYURBLNX, *PUSBPROXYURBLNX;
 
@@ -142 +146 @@
     /** The tail of the landed linux URBs. */
     PUSBPROXYURBLNX     pTaxingTail;
+    /** Are we using sysfs to find the active configuration? */
+    bool                fUsingSysfs;
+    /** The device node/sysfs path of the device.
+     * Used to figure out the configuration after a reset. */
+    char                szPath[1];
 } USBPROXYDEVLNX, *PUSBPROXYDEVLNX;
 
@@ -148 +157 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
-static int usbProxyLinuxDoIoCtl(PUSBPROXYDEV pProxyDev, int iCmd, void *pvArg, bool fHandleNoDev, uint32_t cTries);
+static int usbProxyLinuxDoIoCtl(PUSBPROXYDEV pProxyDev, unsigned long iCmd, void *pvArg, bool fHandleNoDev, uint32_t cTries);
 static void usbProxLinuxUrbUnplugged(PUSBPROXYDEV pProxyDev);
 static void usbProxyLinuxSetConnected(PUSBPROXYDEV pProyxDev, int iIf, bool fConnect, bool fQuiet);
@@ -154 +163 @@
 static void usbProxyLinuxUrbFree(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx);
 static void usbProxyLinuxUrbFreeSplitList(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx);
-static int usbProxyLinuxFindActiveConfig(PUSBPROXYDEV pProxyDev, const char *pszAddress, int *iFirstCfg);
+static int usbProxyLinuxFindActiveConfig(PUSBPROXYDEV pProxyDev, const char *pszPath, int *piFirstCfg);
 
 
@@ -172 +181 @@
  * @internal
  */
-static int usbProxyLinuxDoIoCtl(PUSBPROXYDEV pProxyDev, int iCmd, void *pvArg, bool fHandleNoDev, uint32_t cTries)
+static int usbProxyLinuxDoIoCtl(PUSBPROXYDEV pProxyDev, unsigned long iCmd, void *pvArg, bool fHandleNoDev, uint32_t cTries)
 {
     int rc;
@@ -188 +197 @@
         {
             usbProxLinuxUrbUnplugged(pProxyDev);
-            Log(("usb-linux: ENODEV -> unplugged. pProxyDev=%p[%s]\n", pProxyDev, pProxyDev->Dev.pszName));
+            Log(("usb-linux: ENODEV -> unplugged. pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
             errno = ENODEV;
             break;
@@ -212 +221 @@
      */
     RTCritSectEnter(&pDevLnx->CritSect);
+    pProxyDev->fDetached = true;
 
     PUSBPROXYURBLNX pUrbTaxing = NULL;
@@ -250 +260 @@
 
     RTCritSectLeave(&pDevLnx->CritSect);
-
-    vusbDevUnplugged(&pProxyDev->Dev);
 }
 
@@ -261 +269 @@
 static void usbProxyLinuxSetConnected(PUSBPROXYDEV pProxyDev, int iIf, bool fConnect, bool fQuiet)
 {
-    struct usbdevfs_ioctl IoCtl;
-    if (!fQuiet)
-        LogFlow(("usbProxyLinuxSetConnected: pProxyDev=%p[%s] iIf=%#x fConnect=%d\n",
-                 pProxyDev, pProxyDev->Dev.pszName, iIf, fConnect));
-
-    IoCtl.ifno = iIf;
-    IoCtl.ioctl_code = fConnect ? USBDEVFS_CONNECT : USBDEVFS_DISCONNECT;
-    IoCtl.data = NULL;
-    if (    usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_IOCTL, &IoCtl, true, UINT32_MAX)
-        &&  !fQuiet)
-        Log(("usbProxyLinuxSetConnected: failure, errno=%d. pProxyDev=%p[%s]\n",
-             errno, pProxyDev, pProxyDev->Dev.pszName));
+    if (    iIf >= 32
+        ||  !(pProxyDev->fMaskedIfs & RT_BIT(iIf)))
+    {
+        struct usbdevfs_ioctl IoCtl;
+        if (!fQuiet)
+            LogFlow(("usbProxyLinuxSetConnected: pProxyDev=%s iIf=%#x fConnect=%RTbool\n",
+                     usbProxyGetName(pProxyDev), iIf, fConnect));
+
+        IoCtl.ifno = iIf;
+        IoCtl.ioctl_code = fConnect ? USBDEVFS_CONNECT : USBDEVFS_DISCONNECT;
+        IoCtl.data = NULL;
+        if (    usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_IOCTL, &IoCtl, true, UINT32_MAX)
+            &&  !fQuiet)
+            Log(("usbProxyLinuxSetConnected: failure, errno=%d. pProxyDev=%s\n",
+                 errno, usbProxyGetName(pProxyDev)));
+    }
 }
 
@@ -400 +412 @@
  * @returns The Cfg#.
  * @returns -1 if no active config.
- * @param   pszAddress      The path to the device. We infere the location of the
- *                          devices file, which bus and device number we're looking for.
+ * @param   pszDevNode      The path to the device. We infere the location of
+ *                          the devices file, which bus and device number we're
+ *                          looking for.
  * @param   iFirstCfg       The first configuration. (optional)
  * @internal
  */
-static int usbProxyLinuxFindActiveConfig(PUSBPROXYDEV pProxyDev, const char *pszAddress, int *piFirstCfg)
+static int usbProxyLinuxFindActiveConfigUsbfs(PUSBPROXYDEV pProxyDev, const char *pszDevNode, int *piFirstCfg)
 {
     /*
@@ -415 +428 @@
 
     /*
-     * Interpret the address and turn it into a path to the devices file.
-     */
-    size_t cchAddress = strlen(pszAddress);
-    char *pszDevices = (char *)RTMemDupEx(pszAddress, cchAddress, sizeof("devices"));
+     * Parse the usbfs device node path and turn it into a path to the "devices" file,
+     * picking up the device number and bus along the way.
+     */
+    size_t cchDevNode = strlen(pszDevNode);
+    char *pszDevices = (char *)RTMemDupEx(pszDevNode, cchDevNode, sizeof("devices"));
     AssertReturn(pszDevices, iActiveCfg);
 
     /* the device number */
-    char *psz = pszDevices + cchAddress;
+    char *psz = pszDevices + cchDevNode;
     while (*psz != '/')
         psz--;
@@ -525 +539 @@
 }
 
-int dev2fd (PUSBPROXYDEV pProxyDev)
-{
-    if (pProxyDev)
-    {
-        PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
-
-        if (pDevLnx)
-        {
-            return pDevLnx->File;
-        }
-    }
+
+/**
+ * This finds the active configuration from sysfs.
+ *
+ * @returns The Cfg#.
+ * @returns -1 if no active config.
+ * @param   pszPath         The sysfs path for the device.
+ * @param   piFirstCfg      The first configuration. (optional)
+ * @internal
+ */
+static int usbProxyLinuxFindActiveConfigSysfs(PUSBPROXYDEV pProxyDev, const char *pszPath, int *piFirstCfg)
+{
+#ifdef VBOX_USB_WITH_SYSFS
+    if (piFirstCfg != NULL)
+        *piFirstCfg = pProxyDev->paCfgDescs != NULL
+                    ? pProxyDev->paCfgDescs[0].Core.bConfigurationValue
+                    : 1;
+    return RTLinuxSysFsReadIntFile(10, "%s/bConfigurationValue", pszPath); /* returns -1 on failure */
+#else  /* !VBOX_USB_WITH_SYSFS */
     return -1;
-}
-
-/**
- * Opens the /proc/bus/usb/bus/addr file.
+#endif /* !VBOX_USB_WITH_SYSFS */
+}
+
+
+/**
+ * This finds the active configuration.
+ *
+ * @returns The Cfg#.
+ * @returns -1 if no active config.
+ * @param   pszPath         The sysfs path for the device, or the usbfs device
+ *                          node path.
+ * @param   iFirstCfg       The first configuration. (optional)
+ * @internal
+ */
+static int usbProxyLinuxFindActiveConfig(PUSBPROXYDEV pProxyDev, const char *pszPath, int *piFirstCfg)
+{
+    PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
+    if (pDevLnx->fUsingSysfs)
+        return usbProxyLinuxFindActiveConfigSysfs(pProxyDev, pszPath, piFirstCfg);
+    return usbProxyLinuxFindActiveConfigUsbfs(pProxyDev, pszPath, piFirstCfg);
+}
+
+
+/**
+ * Extracts the Linux file descriptor associated with the kernel USB device.
+ * This is used by rdesktop-vrdp for polling for events.
+ * @returns  the FD, or asserts and returns -1 on error
+ * @param    pProxyDev    The device instance
+ */
+RTDECL(int) USBProxyDeviceLinuxGetFD(PUSBPROXYDEV pProxyDev)
+{
+    PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
+    AssertReturn(pDevLnx->File != NIL_RTFILE, -1);
+    return pDevLnx->File;
+}
+
+
+/**
+ * Opens the device file.
  *
  * @returns VBox status code.
  * @param   pProxyDev       The device instance.
- * @param   pszAddress      The path to the device.
+ * @param   pszAddress      If we are using usbfs, this is the path to the
+ *                          device.  If we are using sysfs, this is a string of
+ *                          the form "sysfs:<sysfs path>//device:<device node>".
+ *                          In the second case, the two paths are guaranteed
+ *                          not to contain the substring "//".
  * @param   pvBackend       Backend specific pointer, unused for the linux backend.
  */
@@ -550 +611 @@
 {
     LogFlow(("usbProxyLinuxOpen: pProxyDev=%p pszAddress=%s\n", pProxyDev, pszAddress));
+    const char *pszDevNode;
+    const char *pszPath;
+    size_t      cchPath;
+    bool        fUsingSysfs;
+
+    /*
+     * Are we using sysfs or usbfs?
+     */
+#ifdef VBOX_USB_WITH_SYSFS
+    fUsingSysfs = strncmp(pszAddress, "sysfs:", sizeof("sysfs:") - 1) == 0;
+    if (fUsingSysfs)
+    {
+        pszDevNode = strstr(pszAddress, "//device:");
+        if (!pszDevNode)
+        {
+            LogRel(("usbProxyLinuxOpen: Invalid device address: '%s'\n", pszAddress));
+            pProxyDev->Backend.pv = NULL;
+            return VERR_INVALID_PARAMETER;
+        }
+
+        pszPath = pszAddress + sizeof("sysfs:") - 1;
+        cchPath = pszDevNode - pszPath;
+        pszDevNode += sizeof("//device:") - 1;
+    }
+    else
+#endif  /* VBOX_USB_WITH_SYSFS */
+    {
+#ifndef VBOX_USB_WITH_SYSFS
+        fUsingSysfs = false;
+#endif
+        pszPath = pszDevNode = pszAddress;
+        cchPath = strlen(pszPath);
+    }
+
+    /*
+     * Try open the device node.
+     */
     RTFILE File;
-    int rc = RTFileOpen(&File, pszAddress, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
+    int rc = RTFileOpen(&File, pszDevNode, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
     if (RT_SUCCESS(rc))
     {
@@ -557 +655 @@
          * Allocate and initialize the linux backend data.
          */
-        PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)RTMemAllocZ(sizeof(*pDevLnx));
+        PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)RTMemAllocZVar(sizeof(*pDevLnx) + cchPath);
         if (pDevLnx)
         {
+            pDevLnx->fUsingSysfs = fUsingSysfs;
+            memcpy(&pDevLnx->szPath[0], pszPath, cchPath);
+            pDevLnx->szPath[cchPath] = '\0';
             pDevLnx->File = File;
             rc = RTCritSectInit(&pDevLnx->CritSect);
@@ -566 +667 @@
                 pProxyDev->Backend.pv = pDevLnx;
 
-                /* brute force rulez */
-                unsigned iIf;
-                for (iIf = 0; iIf < 256; iIf++)
-                    usbProxyLinuxSetConnected(pProxyDev, iIf, false, true);
-
-                /*
-                 * Determin the active configuration.
-                 *
-                 * If there isn't any active configuration, we will get EHOSTUNREACH (113) errors
-                 * when trying to read the device descriptors in usbProxyDevCreate. So, we'll make
-                 * the first one active (usually 1) then.
-                 */
-                pProxyDev->cIgnoreSetConfigs = 1;
-                int iFirstCfg;
-                pProxyDev->iActiveCfg = usbProxyLinuxFindActiveConfig(pProxyDev, pszAddress, &iFirstCfg);
-                if (pProxyDev->iActiveCfg == -1)
-                {
-                    usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_SETCONFIGURATION, &iFirstCfg, false, UINT32_MAX);
-                    pProxyDev->iActiveCfg = usbProxyLinuxFindActiveConfig(pProxyDev, pszAddress, NULL);
-                    Log(("usbProxyLinuxOpen: No active config! Tried to set %d: iActiveCfg=%d\n", iFirstCfg, pProxyDev->iActiveCfg));
-                }
-
                 LogFlow(("usbProxyLinuxOpen(%p, %s): returns successfully File=%d iActiveCfg=%d\n",
                          pProxyDev, pszAddress, pDevLnx->File, pProxyDev->iActiveCfg));
@@ -603 +682 @@
         rc = VERR_VUSB_USBFS_PERMISSION;
 
-    Log(("usbProxyLinuxOpen(%p, %s) failed, rc=%d!\n", pProxyDev, pszAddress, rc));
+    Log(("usbProxyLinuxOpen(%p, %s) failed, rc=%Rrc!\n", pProxyDev, pszAddress, rc));
     pProxyDev->Backend.pv = NULL;
 
@@ -612 +691 @@
 
 /**
+ * Claims all the interfaces and figures out the
+ * current configuration.
+ *
+ * @returns VINF_SUCCESS.
+ * @param   pProxyDev       The proxy device.
+ */
+static int usbProxyLinuxInit(PUSBPROXYDEV pProxyDev)
+{
+    PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
+
+    /*
+     * Brute force rulez.
+     * usbProxyLinuxSetConnected check for masked interfaces.
+     */
+    unsigned iIf;
+    for (iIf = 0; iIf < 256; iIf++)
+        usbProxyLinuxSetConnected(pProxyDev, iIf, false, true);
+
+    /*
+     * Determin the active configuration.
+     *
+     * If there isn't any active configuration, we will get EHOSTUNREACH (113) errors
+     * when trying to read the device descriptors in usbProxyDevCreate. So, we'll make
+     * the first one active (usually 1) then.
+     */
+    pProxyDev->cIgnoreSetConfigs = 1;
+    int iFirstCfg;
+    pProxyDev->iActiveCfg = usbProxyLinuxFindActiveConfig(pProxyDev, pDevLnx->szPath, &iFirstCfg);
+    if (pProxyDev->iActiveCfg == -1)
+    {
+        usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_SETCONFIGURATION, &iFirstCfg, false, UINT32_MAX);
+        pProxyDev->iActiveCfg = usbProxyLinuxFindActiveConfig(pProxyDev, pDevLnx->szPath, NULL);
+        Log(("usbProxyLinuxInit: No active config! Tried to set %d: iActiveCfg=%d\n", iFirstCfg, pProxyDev->iActiveCfg));
+    }
+    else
+        Log(("usbProxyLinuxInit(%p): iActiveCfg=%d\n", pProxyDev, pProxyDev->iActiveCfg));
+    return VINF_SUCCESS;
+}
+
+
+/**
  * Closes the proxy device.
  */
 static void usbProxyLinuxClose(PUSBPROXYDEV pProxyDev)
 {
-    LogFlow(("usbProxyLinuxClose: pProxyDev=%p[%s]\n", pProxyDev, pProxyDev->Dev.pszName));
+    LogFlow(("usbProxyLinuxClose: pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
     PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
     Assert(pDevLnx);
@@ -626 +746 @@
      * Resetting it would be a nice start, although we must remember
      * that it might have been disconnected...
-     */
-    /* ASSUMES: thread == EMT */
-    if (!usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RESET, NULL, false, 10))
-    {
-        /* Connect drivers. */
-        unsigned iIf;
-        for (iIf = 0; iIf < 256; iIf++)
-            usbProxyLinuxSetConnected(pProxyDev, iIf, true, true);
-    }
-    else
-        Log(("usbProxyLinuxClose: Reset failed, errno=%d.\n", errno));
-
-    /*
-     * Now we can close it and free all the resources.
-     */
-    RTFileClose(pDevLnx->File);
-    pDevLnx->File = NIL_RTFILE;
-
+     *
+     * Don't reset if we're masking interfaces or if construction failed.
+     */
+    if (pProxyDev->fInited)
+    {
+        /* ASSUMES: thread == EMT */
+        if (    pProxyDev->fMaskedIfs
+            ||  !usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RESET, NULL, false, 10))
+        {
+            /* Connect drivers. */
+            unsigned iIf;
+            for (iIf = 0; iIf < 256; iIf++)
+                usbProxyLinuxSetConnected(pProxyDev, iIf, true, true);
+            LogRel(("USB: Successfully reset device pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
+        }
+        else if (errno != ENODEV)
+            LogRel(("USB: Reset failed, errno=%d, pProxyDev=%s.\n", errno, usbProxyGetName(pProxyDev)));
+        else
+            Log(("USB: Reset failed, errno=%d (ENODEV), pProxyDev=%s.\n", errno, usbProxyGetName(pProxyDev)));
+    }
+
+    /*
+     * Now we can free all the resources and close the device.
+     */
     RTCritSectDelete(&pDevLnx->CritSect);
 
@@ -679 +805 @@
         RTMemFree(pUrbLnx);
     }
+
+    RTFileClose(pDevLnx->File);
+    pDevLnx->File = NIL_RTFILE;
 
     RTMemFree(pDevLnx);
@@ -808 +937 @@
                 /* Skip past "S:" and then the whitespace */
                 for(psz = buf + 2; *psz != '\0'; psz++)
-                    if ( !isspace(*psz) )
+                    if ( !RT_C_IS_SPACE(*psz) )
                         break;
 
@@ -878 +1007 @@
  * @param   pDev    The device to reset.
  */
-static int usbProxyLinuxReset(PUSBPROXYDEV pProxyDev)
+static int usbProxyLinuxReset(PUSBPROXYDEV pProxyDev, bool fResetOnLinux)
 {
 #ifdef NO_PORT_RESET
-    LogFlow(("usbProxyLinuxReset: pProxyDev=%p[%s] - NO_PORT_RESET\n", pProxyDev, pProxyDev->Dev.pszName));
+    PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
+
+    /*
+     * Specific device resets are NOPs.
+     * Root hub resets that affects all devices are executed.
+     *
+     * The reasoning is that when a root hub reset is done, the guest shouldn't
+     * will have to re enumerate the devices after doing this kind of reset.
+     * So, it doesn't really matter if a device is 'logically disconnected'.
+     */
+    if (    !fResetOnLinux
+        ||  pProxyDev->fMaskedIfs)
+        LogFlow(("usbProxyLinuxReset: pProxyDev=%s - NO_PORT_RESET\n", usbProxyGetName(pProxyDev)));
+    else
+    {
+        LogFlow(("usbProxyLinuxReset: pProxyDev=%s - Real Reset!\n", usbProxyGetName(pProxyDev)));
+        if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RESET, NULL, false, 10))
+        {
+            int rc = errno;
+            Log(("usb-linux: Reset failed, rc=%Rrc errno=%d.\n", RTErrConvertFromErrno(rc), rc));
+            pProxyDev->iActiveCfg = -1;
+            return RTErrConvertFromErrno(rc);
+        }
+
+        /* find the active config - damn annoying. */
+        pProxyDev->iActiveCfg = usbProxyLinuxFindActiveConfig(pProxyDev, pDevLnx->szPath, NULL);
+        LogFlow(("usbProxyLinuxReset: returns successfully iActiveCfg=%d\n", pProxyDev->iActiveCfg));
+    }
     pProxyDev->cIgnoreSetConfigs = 2;
 
 #else /* !NO_PORT_RESET */
-    LogFlow(("usbProxyLinuxReset: pProxyDev=%p[%s]\n", pProxyDev, pProxyDev->Dev.pszName));
+
+    /*
+     * This is the alternative, we will allways reset when asked to do so.
+     *
+     * The problem we're facing here is that on reset failure linux will do
+     * a 'logical reconnect' on the device. This will invalidate the current
+     * handle and we'll have to reopen the device. This is problematic to say
+     * the least, especially since it happens pretty often.
+     */
+    LogFlow(("usbProxyLinuxReset: pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
 # ifndef NO_LOGICAL_RECONNECT
     ASMAtomicIncU32(&g_cResetActive);
@@ -941 +1106 @@
 static int usbProxyLinuxSetConfig(PUSBPROXYDEV pProxyDev, int iCfg)
 {
-    LogFlow(("usbProxyLinuxSetConfig: pProxyDev=%p[%s] cfg=%#x\n",
-             pProxyDev, pProxyDev->Dev.pszName, iCfg));
+    LogFlow(("usbProxyLinuxSetConfig: pProxyDev=%s cfg=%#x\n",
+             usbProxyGetName(pProxyDev), iCfg));
 
     if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_SETCONFIGURATION, &iCfg, true, UINT32_MAX))
@@ -959 +1124 @@
 static int usbProxyLinuxClaimInterface(PUSBPROXYDEV pProxyDev, int iIf)
 {
-    LogFlow(("usbProxyLinuxClaimInterface: pProxyDev=%p[%s] ifnum=%#x\n", pProxyDev, pProxyDev->Dev.pszName, iIf));
+    LogFlow(("usbProxyLinuxClaimInterface: pProxyDev=%s ifnum=%#x\n", usbProxyGetName(pProxyDev), iIf));
     usbProxyLinuxSetConnected(pProxyDev, iIf, false, false);
 
     if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_CLAIMINTERFACE, &iIf, true, UINT32_MAX))
     {
-        Log(("usb-linux: Claim interface. errno=%d pProxyDev=%p[%s]\n", errno, pProxyDev, pProxyDev->Dev.pszName));
+        Log(("usb-linux: Claim interface. errno=%d pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
         return false;
     }
@@ -977 +1142 @@
 static int usbProxyLinuxReleaseInterface(PUSBPROXYDEV pProxyDev, int iIf)
 {
-    LogFlow(("usbProxyLinuxReleaseInterface: pProxyDev=%p[%s] ifnum=%#x\n", pProxyDev, pProxyDev->Dev.pszName, iIf));
+    LogFlow(("usbProxyLinuxReleaseInterface: pProxyDev=%s ifnum=%#x\n", usbProxyGetName(pProxyDev), iIf));
 
     if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RELEASEINTERFACE, &iIf, true, UINT32_MAX))
     {
-        Log(("usb-linux: Release interface, errno=%d. pProxyDev=%p[%s]\n", errno, pProxyDev, pProxyDev->Dev.pszName));
+        Log(("usb-linux: Release interface, errno=%d. pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
         return false;
     }
@@ -1002 +1167 @@
     if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_SETINTERFACE, &SetIf, true, UINT32_MAX))
     {
-        Log(("usb-linux: Set interface, errno=%d. pProxyDev=%p[%s]\n", errno, pProxyDev, pProxyDev->Dev.pszName));
+        Log(("usb-linux: Set interface, errno=%d. pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
         return false;
     }
@@ -1014 +1179 @@
 static bool usbProxyLinuxClearHaltedEp(PUSBPROXYDEV pProxyDev, unsigned int EndPt)
 {
-    LogFlow(("usbProxyLinuxClearHaltedEp: pProxyDev=%p[%s] EndPt=%u\n", pProxyDev, pProxyDev->Dev.pszName, EndPt));
+    LogFlow(("usbProxyLinuxClearHaltedEp: pProxyDev=%s EndPt=%u\n", usbProxyGetName(pProxyDev), EndPt));
 
     if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_CLEAR_HALT, &EndPt, true, UINT32_MAX))
@@ -1025 +1190 @@
         if (errno == ENOENT)
         {
-            Log(("usb-linux: clear_halted_ep failed errno=%d. pProxyDev=%p[%s] ep=%d - IGNORED\n",
-                 errno, pProxyDev, pProxyDev->Dev.pszName, EndPt));
+            Log(("usb-linux: clear_halted_ep failed errno=%d. pProxyDev=%s ep=%d - IGNORED\n",
+                 errno, usbProxyGetName(pProxyDev), EndPt));
             return true;
         }
-        Log(("usb-linux: clear_halted_ep failed errno=%d. pProxyDev=%p[%s] ep=%d\n",
-             errno, pProxyDev, pProxyDev->Dev.pszName, EndPt));
+        Log(("usb-linux: clear_halted_ep failed errno=%d. pProxyDev=%s ep=%d\n",
+             errno, usbProxyGetName(pProxyDev), EndPt));
         return false;
     }
@@ -1042 +1207 @@
 static void usbProxyLinuxUrbSwapSetup(PVUSBSETUP pSetup)
 {
-    pSetup->wValue = RT_LE2H_U16(pSetup->wValue);
-    pSetup->wIndex = RT_LE2H_U16(pSetup->wIndex);
-    pSetup->wLength = RT_LE2H_U16(pSetup->wLength);
-}
-
-
-/** The split size. */
-#define SPLIT_SIZE 0x2000
-
-/**
- * Try split up a VUSB URB into smaller URBs which the
- * linux kernel can deal with.
+    pSetup->wValue = RT_H2LE_U16(pSetup->wValue);
+    pSetup->wIndex = RT_H2LE_U16(pSetup->wIndex);
+    pSetup->wLength = RT_H2LE_U16(pSetup->wLength);
+}
+
+
+/**
+ * Clean up after a failed URB submit.
+ */
+static void usbProxyLinuxCleanupFailedSubmit(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx, PUSBPROXYURBLNX pCur, PVUSBURB pUrb, bool *pfUnplugged)
+{
+    if (pUrb->enmType == VUSBXFERTYPE_MSG)
+        usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
+
+    /* discard and reap later (walking with pUrbLnx). */
+    if (pUrbLnx != pCur)
+    {
+        for (;;)
+        {
+            pUrbLnx->fCanceledBySubmit = true;
+            pUrbLnx->KUrb.usercontext = NULL;
+            if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pUrbLnx->KUrb, false, UINT32_MAX))
+            {
+                if (errno == ENODEV)
+                    *pfUnplugged = true;
+                else if (errno == ENOENT)
+                    pUrbLnx->fSplitElementReaped = true;
+                else
+                    LogRel(("USB: Failed to discard %p! errno=%d (pUrb=%p)\n", pUrbLnx->KUrb.usercontext, errno, pUrb)); /* serious! */
+            }
+            if (pUrbLnx->pSplitNext == pCur)
+            {
+                pUrbLnx->pSplitNext = NULL;
+                break;
+            }
+            pUrbLnx = pUrbLnx->pSplitNext; Assert(pUrbLnx);
+        }
+    }
+
+    /* free the unsubmitted ones. */
+    while (pCur)
+    {
+        PUSBPROXYURBLNX pFree = pCur;
+        pCur = pCur->pSplitNext;
+        usbProxyLinuxUrbFree(pProxyDev, pFree);
+    }
+
+    /* send unplug event if we failed with ENODEV originally. */
+    if (*pfUnplugged)
+        usbProxLinuxUrbUnplugged(pProxyDev);
+}
+
+/**
+ * Submit one URB through the usbfs IOCTL interface, with
+ * retries
+ *
+ * @returns true / false.
+ */
+static bool usbProxyLinuxSubmitURB(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pCur, PVUSBURB pUrb, bool *pfUnplugged)
+{
+    PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
+    unsigned        cTries = 0;
+
+    while (ioctl(pDevLnx->File, USBDEVFS_SUBMITURB, &pCur->KUrb))
+    {
+        if (errno == EINTR)
+            continue;
+        if (errno == ENODEV)
+        {
+            Log(("usbProxyLinuxSubmitURB: ENODEV -> unplugged. pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
+            *pfUnplugged = true;
+            return false;
+        }
+
+        Log(("usb-linux: Submit URB %p -> %d!!! type=%d ep=%#x buffer_length=%#x cTries=%d\n",
+             pUrb, errno, pCur->KUrb.type, pCur->KUrb.endpoint, pCur->KUrb.buffer_length, cTries));
+        if (errno != EBUSY && ++cTries < 3) /* this doesn't work for the floppy :/ */
+        {
+            pCur->u64SubmitTS = RTTimeMilliTS();
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+
+/** The split size. 16K in known Linux kernel versions. */
+#define SPLIT_SIZE 0x4000
+
+/**
+ * Create a URB fragment of up to SPLIT_SIZE size and hook it
+ * into the list of fragments.
+ *
+ * @returns pointer to newly allocated URB fragment or NULL.
+ */
+static PUSBPROXYURBLNX usbProxyLinuxSplitURBFragment(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pHead, PUSBPROXYURBLNX pCur)
+{
+    PUSBPROXYURBLNX     pNew;
+    uint32_t            cbLeft = pCur->cbSplitRemaining;
+    uint8_t             *pb = (uint8_t *)pCur->KUrb.buffer;
+
+    Assert(cbLeft != 0);
+    pNew = pCur->pSplitNext = usbProxyLinuxUrbAlloc(pProxyDev, pHead);
+    if (!pNew)
+    {
+        usbProxyLinuxUrbFreeSplitList(pProxyDev, pHead);
+        return NULL;
+    }
+    Assert(pHead->pNext != pNew); Assert(pHead->pPrev != pNew); Assert(pNew->pNext == pNew->pPrev);
+    Assert(pNew->pSplitHead == pHead);
+    Assert(pNew->pSplitNext == NULL);
+
+    pNew->KUrb = pHead->KUrb;
+    pNew->KUrb.buffer = pb + pCur->KUrb.buffer_length;
+    pNew->KUrb.buffer_length = RT_MIN(cbLeft, SPLIT_SIZE);
+    pNew->KUrb.actual_length = 0;
+
+    cbLeft -= pNew->KUrb.buffer_length;
+    Assert(cbLeft < INT32_MAX);
+    pNew->cbSplitRemaining = cbLeft;
+    return pNew;
+}
+
+/**
+ * Try splitting up a VUSB URB into smaller URBs which the
+ * linux kernel (usbfs) can deal with.
+ *
+ * NB: For ShortOK reads things get a little tricky - we don't
+ * know how much data is going to arrive and not all the
+ * fragment URBs might be filled. We can only safely set up one
+ * URB at a time -> worse performance but correct behaviour.
  *
  * @returns true / false.
@@ -1062 +1346 @@
 static int usbProxyLinuxUrbQueueSplit(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx, PVUSBURB pUrb)
 {
-    unsigned        cTries;
-    PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
-
     /*
      * Split it up into SPLIT_SIZE sized blocks.
@@ -1080 +1361 @@
         case VUSBXFERTYPE_BULK: pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_BULK; break;
         case VUSBXFERTYPE_INTR: pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_INTERRUPT; break;
-        case VUSBXFERTYPE_ISOC: pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_ISO; break;
         case VUSBXFERTYPE_MSG:  pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_CONTROL; break;
+        case VUSBXFERTYPE_ISOC:
+            AssertMsgFailed(("We can't split isochronous URBs!\n"));
+            usbProxyLinuxUrbFree(pProxyDev, pUrbLnx);
+            return false;
     }
     pUrbLnx->KUrb.endpoint          = pUrb->EndPt;
@@ -1089 +1373 @@
     pUrbLnx->KUrb.flags             = pUrb->fShortNotOk ? USBDEVFS_URB_SHORT_NOT_OK : 0; /* ISO_ASAP too? */
     pUrbLnx->KUrb.buffer            = pb;
-    pUrbLnx->KUrb.buffer_length     = MIN(cbLeft, SPLIT_SIZE);
+    pUrbLnx->KUrb.buffer_length     = RT_MIN(cbLeft, SPLIT_SIZE);
     pUrbLnx->KUrb.actual_length     = 0;
     pUrbLnx->KUrb.start_frame       = 0;
@@ -1099 +1383 @@
     pUrbLnx->pSplitNext = NULL;
 
-    pb += pUrbLnx->KUrb.buffer_length;
+    PUSBPROXYURBLNX pCur = pUrbLnx;
+
     cbLeft -= pUrbLnx->KUrb.buffer_length;
-
-    /* the rest. */
-    unsigned i;
-    PUSBPROXYURBLNX pCur = pUrbLnx;
-    for (i = 1; i < cKUrbs; i++)
-    {
-        Assert(cbLeft != 0);
-        pCur = pCur->pSplitNext = usbProxyLinuxUrbAlloc(pProxyDev, pUrbLnx);
-        if (!pCur)
-        {
-            usbProxyLinuxUrbFreeSplitList(pProxyDev, pUrbLnx);
-            return false;
-        }
-        Assert(pUrbLnx->pNext != pCur); Assert(pUrbLnx->pPrev != pCur); Assert(pCur->pNext == pCur->pPrev);
-        Assert(pCur->pSplitHead == pUrbLnx);
-        Assert(pCur->pSplitNext == NULL);
-
-        pCur->KUrb = pUrbLnx->KUrb;
-        pCur->KUrb.buffer = pb;
-        pCur->KUrb.buffer_length = MIN(cbLeft, SPLIT_SIZE);
-        pCur->KUrb.actual_length = 0;
-
-        pb += pCur->KUrb.buffer_length;
-        cbLeft -= pCur->KUrb.buffer_length;
-    }
-    Assert(cbLeft == 0);
-
-    /*
-     * Submit them.
-     */
+    pUrbLnx->cbSplitRemaining = cbLeft;
+
+    bool fSucceeded = false;
     bool fUnplugged = false;
-    bool fFailed = false;
-    pCur = pUrbLnx;
-    for (i = 0; i < cKUrbs; i++, pCur = pCur->pSplitNext)
-    {
-        cTries = 0;
-        while (ioctl(pDevLnx->File, USBDEVFS_SUBMITURB, &pCur->KUrb))
-        {
-            if (errno == EINTR)
-                continue;
-            if (errno == ENODEV)
+    if (pUrb->enmDir == VUSBDIRECTION_IN && !pUrb->fShortNotOk)
+    {
+        /* Subsequent fragments will be queued only after the previous fragment is reaped
+         * and only if necessary.
+         */
+        fSucceeded = true;
+        Log(("usb-linux: Large ShortOK read, only queuing first fragment.\n"));
+        Assert(pUrbLnx->cbSplitRemaining > 0 && pUrbLnx->cbSplitRemaining < 256 * _1K);
+        fSucceeded = usbProxyLinuxSubmitURB(pProxyDev, pUrbLnx, pUrb, &fUnplugged);
+    }
+    else
+    {
+        /* the rest. */
+        unsigned i;
+        for (i = 1; i < cKUrbs; i++)
+        {
+            pCur = usbProxyLinuxSplitURBFragment(pProxyDev, pUrbLnx, pCur);
+            if (!pCur)
             {
-                Log(("usbProxyLinuxUrbQueueSplit: ENODEV -> unplugged. pProxyDev=%p[%s]\n", pProxyDev, pProxyDev->Dev.pszName));
-                fFailed = fUnplugged = true;
+                return false;
+            }
+        }
+        Assert(pCur->cbSplitRemaining == 0);
+
+        /* Submit the blocks. */
+        pCur = pUrbLnx;
+        for (i = 0; i < cKUrbs; i++, pCur = pCur->pSplitNext)
+        {
+            fSucceeded = usbProxyLinuxSubmitURB(pProxyDev, pCur, pUrb, &fUnplugged);
+            if (!fSucceeded)
                 break;
-            }
-
-            Log(("usb-linux: Queue URB %p -> %d!!! type=%d ep=%#x buffer_length=%#x cTries=%d\n",
-                 pUrb, errno, pCur->KUrb.type, pCur->KUrb.endpoint, pCur->KUrb.buffer_length, cTries));
-            if (errno != EBUSY && ++cTries < 3) /* this doesn't work for the floppy :/ */
-                continue;
-            fFailed = true;
-            break;
-        }
-        if (fFailed)
-            break;
-        pCur->u64SubmitTS = RTTimeMilliTS();
-    }
-    if (!fFailed)
+        }
+    }
+
+    if (fSucceeded)
     {
         pUrb->Dev.pvPrivate = pUrbLnx;
@@ -1166 +1431 @@
     }
 
-    /*
-     * Clean up.
-     */
-    if (pUrb->enmType == VUSBXFERTYPE_MSG)
-        usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
-
-    /* discard and reap later (walking with pUrbLnx). */
-    if (pUrbLnx != pCur)
-    {
-        for (;;)
-        {
-            pUrbLnx->fCanceledBySubmit = true;
-            pUrbLnx->KUrb.usercontext = NULL;
-            if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pUrbLnx->KUrb, false, UINT32_MAX))
-            {
-                if (errno == ENODEV)
-                    fUnplugged = true;
-                else if (errno == ENOENT)
-                    pUrbLnx->fSplitElementReaped = true;
-                else
-                    LogRel(("SUB: Failed to discard %p! errno=%d (pUrb=%p)\n", pUrbLnx->KUrb.usercontext, errno, pUrb)); /* serious! */
-            }
-            if (pUrbLnx->pSplitNext == pCur)
-            {
-                pUrbLnx->pSplitNext = NULL;
-                break;
-            }
-            pUrbLnx = pUrbLnx->pSplitNext; Assert(pUrbLnx);
-        }
-    }
-
-    /* free the unsubmitted ones. */
-    while (pCur)
-    {
-        PUSBPROXYURBLNX pFree = pCur;
-        pCur = pCur->pSplitNext;
-        usbProxyLinuxUrbFree(pProxyDev, pFree);
-    }
-
-    /* send unplug event if we failed with ENODEV originally. */
-    if (fUnplugged)
-        usbProxLinuxUrbUnplugged(pProxyDev);
+    usbProxyLinuxCleanupFailedSubmit(pProxyDev, pUrbLnx, pCur, pUrb, &fUnplugged);
     return false;
 }
@@ -1213 +1437 @@
 
 /**
- * @copydoc USBPROXYBACK::pfbUrbQueue
+ * @copydoc USBPROXYBACK::pfnUrbQueue
  */
 static int usbProxyLinuxUrbQueue(PVUSBURB pUrb)
 {
     unsigned        cTries;
-    PUSBPROXYDEV    pProxyDev = (PUSBPROXYDEV)pUrb->pDev;
+#ifndef RDESKTOP
+    PUSBPROXYDEV    pProxyDev = PDMINS_2_DATA(pUrb->pUsbIns, PUSBPROXYDEV);
+#else
+    PUSBPROXYDEV    pProxyDev = usbProxyFromVusbDev(pUrb->pDev);
+#endif
     PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
-    LogFlow(("usbProxyLinuxUrbQueue: pProxyDev=%p[%s] pUrb=%p EndPt=%d cbData=%d\n",
-             pProxyDev, pProxyDev->Dev.pszName, pUrb, pUrb->EndPt, pUrb->cbData));
+    LogFlow(("usbProxyLinuxUrbQueue: pProxyDev=%s pUrb=%p EndPt=%d cbData=%d\n",
+             usbProxyGetName(pProxyDev), pUrb, pUrb->EndPt, pUrb->cbData));
 
     /*
@@ -1229 +1457 @@
     if (!pUrbLnx)
         return false;
+
+    pUrbLnx->KUrb.endpoint          = pUrb->EndPt | (pUrb->enmDir == VUSBDIRECTION_IN ? 0x80 : 0);
+    pUrbLnx->KUrb.status            = 0;
+    pUrbLnx->KUrb.flags             = pUrb->fShortNotOk ? USBDEVFS_URB_SHORT_NOT_OK : 0;
+    pUrbLnx->KUrb.buffer            = pUrb->abData;
+    pUrbLnx->KUrb.buffer_length     = pUrb->cbData;
+    pUrbLnx->KUrb.actual_length     = 0;
+    pUrbLnx->KUrb.start_frame       = 0;
+    pUrbLnx->KUrb.number_of_packets = 0;
+    pUrbLnx->KUrb.error_count       = 0;
+    pUrbLnx->KUrb.signr             = 0;
+    pUrbLnx->KUrb.usercontext       = pUrb;
 
     switch (pUrb->enmType)
@@ -1247 +1487 @@
         case VUSBXFERTYPE_ISOC:
             pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_ISO;
+            pUrbLnx->KUrb.flags |= USBDEVFS_URB_ISO_ASAP;
+            pUrbLnx->KUrb.number_of_packets = pUrb->cIsocPkts;
+            unsigned i;
+            for (i = 0; i < pUrb->cIsocPkts; i++)
+            {
+                pUrbLnx->KUrb.iso_frame_desc[i].length = pUrb->aIsocPkts[i].cb;
+                pUrbLnx->KUrb.iso_frame_desc[i].actual_length = 0;
+                pUrbLnx->KUrb.iso_frame_desc[i].status = 0x7fff;
+            }
             break;
         case VUSBXFERTYPE_INTR:
@@ -1254 +1503 @@
             goto l_err;
     }
-    pUrbLnx->KUrb.endpoint          = pUrb->EndPt;
-    pUrbLnx->KUrb.status            = 0;
-    pUrbLnx->KUrb.flags             = pUrb->fShortNotOk ? USBDEVFS_URB_SHORT_NOT_OK : 0; /* ISO_ASAP too? */
-    pUrbLnx->KUrb.buffer            = pUrb->abData;
-    pUrbLnx->KUrb.buffer_length     = pUrb->cbData;
-    pUrbLnx->KUrb.actual_length     = 0;
-    pUrbLnx->KUrb.start_frame       = 0;
-    pUrbLnx->KUrb.number_of_packets = 0;
-    pUrbLnx->KUrb.error_count       = 0;
-    pUrbLnx->KUrb.signr             = 0;
-    pUrbLnx->KUrb.usercontext       = pUrb;
-    switch (pUrb->enmDir)
-    {
-        case VUSBDIRECTION_IN:
-            pUrbLnx->KUrb.endpoint |= 0x80;
-            break;
-        case VUSBDIRECTION_OUT:
-            break;
-        default:
-            AssertMsgFailed(("usbProxyLinuxUrbQueue: Invalid directorion %d\n", pUrb->enmDir));
-            goto l_err;
-    }
 
     /*
@@ -1287 +1514 @@
         if (errno == ENODEV)
         {
-            Log(("usbProxyLinuxUrbQueue: ENODEV -> unplugged. pProxyDev=%p[%s]\n", pProxyDev, pProxyDev->Dev.pszName));
+            Log(("usbProxyLinuxUrbQueue: ENODEV -> unplugged. pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
             if (pUrb->enmType == VUSBXFERTYPE_MSG)
                 usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
@@ -1356 +1583 @@
                 Assert(pCur == pCur->pSplitHead);
                 unsigned cFailures = 0;
-                PUSBPROXYURBLNX pCur2;
-                for ( pCur2 = pCur; pCur2; pCur2 = pCur2->pSplitNext)
+                PUSBPROXYURBLNX pCur2;
+                for (pCur2 = pCur; pCur2; pCur2 = pCur2->pSplitNext)
                 {
                     if (pCur2->fSplitElementReaped)
@@ -1370 +1597 @@
                         goto l_leave; /* ENODEV means break and everything cancelled elsewhere. */
                 }
-                LogRel(("USB: Cancelled URB (%p) after %lldms!! (cFailures=%d)\n",
-                        pCur->KUrb.usercontext, u64MilliTS - pCur->u64SubmitTS, cFailures));
+                LogRel(("USB: Cancelled URB (%p) after %llums!! (cFailures=%d)\n",
+                        pCur->KUrb.usercontext, (long long unsigned) u64MilliTS - pCur->u64SubmitTS, cFailures));
             }
             else
@@ -1380 +1607 @@
                 {
                     pCur->fCanceledByTimedOut = true;
-                    LogRel(("USB: Cancelled URB (%p) after %lldms!!\n", pCur->KUrb.usercontext, u64MilliTS - pCur->u64SubmitTS));
+                    LogRel(("USB: Cancelled URB (%p) after %llums!!\n", pCur->KUrb.usercontext, (long long unsigned) u64MilliTS - pCur->u64SubmitTS));
                 }
                 else if (errno != ENODEV)
@@ -1388 +1615 @@
             }
         }
+#if 0
+        /* Disabled for the time beeing as some USB devices have URBs pending for an unknown amount of time.
+         * One example is the OmniKey CardMan 3821. */
         else if (u64MilliTS - pCur->u64SubmitTS >= 200*1000 /* 200 sec (180 sec has been observed with XP) */)
             pCur->fTimedOut = true;
+#endif
     }
 
@@ -1398 +1629 @@
 
 /**
- * Get and translates the linux status to a VUSB status.
- */
-static VUSBSTATUS vusbProxyLinuxUrbGetStatus(PUSBPROXYURBLNX pUrbLnx)
-{
-    switch (pUrbLnx->KUrb.status)
-    {
+ * Translate the linux status to a VUSB status.
+ *
+ * @remarks see cc_to_error in ohci.h, uhci_map_status in uhci-q.c,
+ *          sitd_complete+itd_complete in ehci-sched.c, and qtd_copy_status in
+ *          ehci-q.c.
+ */
+static VUSBSTATUS vusbProxyLinuxStatusToVUsbStatus(int iStatus)
+{
+    switch (iStatus)
+    {
+        /** @todo VUSBSTATUS_NOT_ACCESSED */
+        case -EXDEV: /* iso transfer, partial result. */
         case 0:
-            if (!pUrbLnx->fCanceledByTimedOut)
-                return VUSBSTATUS_OK;
-            /* fall thru */
+            return VUSBSTATUS_OK;
 
         case -EILSEQ:
@@ -1413 +1648 @@
 
         case -EREMOTEIO: /* ehci and ohci uses this for underflow error. */
-            return VUSBSTATUS_UNDERFLOW;
-
+            return VUSBSTATUS_DATA_UNDERRUN;
+        case -EOVERFLOW:
+            return VUSBSTATUS_DATA_OVERRUN;
+
+        case -ETIME:
         case -ENODEV:
             return VUSBSTATUS_DNR;
@@ -1426 +1664 @@
         //    return VUSBSTATUS_BIT_STUFFING;
 
+        case -EPIPE:
+            Log(("vusbProxyLinuxStatusToVUsbStatus: STALL/EPIPE!!\n"));
+            return VUSBSTATUS_STALL;
+
+        case -ESHUTDOWN:
+            Log(("vusbProxyLinuxStatusToVUsbStatus: SHUTDOWN!!\n"));
+            return VUSBSTATUS_STALL;
+
         default:
-            Log(("usbProxyLinuxUrbReap: pKUrb status %d!!\n", pUrbLnx->KUrb.status));
+            Log(("vusbProxyLinuxStatusToVUsbStatus: status %d!!\n", iStatus));
             return VUSBSTATUS_STALL;
     }
+}
+
+
+/**
+ * Get and translates the linux status to a VUSB status.
+ */
+static VUSBSTATUS vusbProxyLinuxUrbGetStatus(PUSBPROXYURBLNX pUrbLnx)
+{
+    if (    pUrbLnx->fCanceledByTimedOut
+        &&  pUrbLnx->KUrb.status == 0)
+        return VUSBSTATUS_CRC;
+    return vusbProxyLinuxStatusToVUsbStatus(pUrbLnx->KUrb.status);
 }
 
@@ -1441 +1699 @@
  * @param   cMillies    Number of milliseconds to wait. Use 0 to not wait at all.
  */
-static PVUSBURB usbProxyLinuxUrbReap(PUSBPROXYDEV pProxyDev, unsigned cMillies)
+static PVUSBURB usbProxyLinuxUrbReap(PUSBPROXYDEV pProxyDev, RTMSINTERVAL cMillies)
 {
     PUSBPROXYURBLNX pUrbLnx = NULL;
@@ -1511 +1769 @@
                 if (errno != EAGAIN)
                 {
-                    Log(("usb-linux: Reap URB - poll -> %d errno=%d pProxyDev=%p[%s]\n", rc, errno, pProxyDev, pProxyDev->Dev.pszName));
+                    Log(("usb-linux: Reap URB - poll -> %d errno=%d pProxyDev=%s\n", rc, errno, usbProxyGetName(pProxyDev)));
                     return NULL;
                 }
@@ -1532 +1790 @@
                         vusbProxyLinuxUrbDoTimeouts(pProxyDev, pDevLnx);
                     else
-                        Log(("usb-linux: Reap URB. errno=%d pProxyDev=%p[%s]\n", errno, pProxyDev, pProxyDev->Dev.pszName));
+                        Log(("usb-linux: Reap URB. errno=%d pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
                     return NULL;
                 }
@@ -1541 +1799 @@
             {
                 pUrbLnx->fSplitElementReaped = true;
-                PUSBPROXYURBLNX pCur;
+
+                /* for variable size URBs, we may need to queue more if the just-reaped URB was completely filled */
+                if (pUrbLnx->cbSplitRemaining && (pKUrb->actual_length == pKUrb->buffer_length) && !pUrbLnx->pSplitNext)
+                {
+                    bool fUnplugged = false;
+                    bool fSucceeded;
+
+                    Assert(pUrbLnx->pSplitHead);
+                    Assert((pKUrb->endpoint & 0x80) && (!pKUrb->flags & USBDEVFS_URB_SHORT_NOT_OK));
+                    PUSBPROXYURBLNX pNew = usbProxyLinuxSplitURBFragment(pProxyDev, pUrbLnx->pSplitHead, pUrbLnx);
+                    if (!pNew)
+                    {
+                        Log(("usb-linux: Allocating URB fragment failed. errno=%d pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
+                        return NULL;
+                    }
+                    PVUSBURB pUrb = (PVUSBURB)pUrbLnx->KUrb.usercontext;
+                    fSucceeded = usbProxyLinuxSubmitURB(pProxyDev, pNew, pUrb, &fUnplugged);
+                    if (fUnplugged)
+                        usbProxLinuxUrbUnplugged(pProxyDev);
+                    if (!fSucceeded)
+                        return NULL;
+                    continue;   /* try reaping another URB */
+                }
+                PUSBPROXYURBLNX pCur;
                 for (pCur = pUrbLnx->pSplitHead; pCur; pCur = pCur->pSplitNext)
                     if (!pCur->fSplitElementReaped)
@@ -1569 +1850 @@
             uint8_t *pbEnd = &pUrb->abData[0];
             pUrb->enmStatus = VUSBSTATUS_OK;
-            PUSBPROXYURBLNX pCur;
+            PUSBPROXYURBLNX pCur;
             for (pCur = pUrbLnx; pCur; pCur = pCur->pSplitNext)
             {
@@ -1585 +1866 @@
             pUrb->enmStatus = vusbProxyLinuxUrbGetStatus(pUrbLnx);
             pUrb->cbData = pUrbLnx->KUrb.actual_length;
+            if (pUrb->enmType == VUSBXFERTYPE_ISOC)
+            {
+                unsigned i, off;
+                for (i = 0, off = 0; i < pUrb->cIsocPkts; i++)
+                {
+                    pUrb->aIsocPkts[i].enmStatus = vusbProxyLinuxStatusToVUsbStatus(pUrbLnx->KUrb.iso_frame_desc[i].status);
+                    Assert(pUrb->aIsocPkts[i].off == off);
+                    pUrb->aIsocPkts[i].cb = pUrbLnx->KUrb.iso_frame_desc[i].actual_length;
+                    off += pUrbLnx->KUrb.iso_frame_desc[i].length;
+                }
+            }
             usbProxyLinuxUrbFree(pProxyDev, pUrbLnx);
         }
@@ -1602 +1894 @@
     }
 
-    LogFlow(("usbProxyLinuxUrbReap: dev=%p[%s] returns %p\n", pProxyDev, pProxyDev->Dev.pszName, pUrb));
+    LogFlow(("usbProxyLinuxUrbReap: pProxyDev=%s returns %p\n", usbProxyGetName(pProxyDev), pUrb));
     return pUrb;
 }
@@ -1613 +1905 @@
 static void usbProxyLinuxUrbCancel(PVUSBURB pUrb)
 {
-    PUSBPROXYDEV pProxyDev = (PUSBPROXYDEV)pUrb->pDev;
+#ifndef RDESKTOP
+    PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pUrb->pUsbIns, PUSBPROXYDEV);
+#else
+    PUSBPROXYDEV pProxyDev = usbProxyFromVusbDev(pUrb->pDev);
+#endif
     PUSBPROXYURBLNX pUrbLnx = (PUSBPROXYURBLNX)pUrb->Dev.pvPrivate;
     if (pUrbLnx->pSplitHead)
@@ -1619 +1915 @@
         /* split */
         Assert(pUrbLnx == pUrbLnx->pSplitHead);
-        PUSBPROXYURBLNX pCur;
+        PUSBPROXYURBLNX pCur;
         for (pCur = pUrbLnx; pCur; pCur = pCur->pSplitNext)
         {
@@ -1629 +1925 @@
             if (errno == ENODEV)
                 break;
-            Log(("usb-linux: Discard URB %p failed, errno=%d. pProxyDev=%p[%s]!!! (split)\n",
-                 pUrb, errno, pProxyDev, pProxyDev->Dev.pszName));
+            Log(("usb-linux: Discard URB %p failed, errno=%d. pProxyDev=%s!!! (split)\n",
+                 pUrb, errno, usbProxyGetName(pProxyDev)));
         }
     }
@@ -1639 +1935 @@
             &&  errno != ENODEV /* deal with elsewhere. */
             &&  errno != ENOENT)
-            Log(("usb-linux: Discard URB %p failed, errno=%d. pProxyDev=%p[%s]!!!\n",
-                 pUrb, errno, pProxyDev, pProxyDev->Dev.pszName));
+            Log(("usb-linux: Discard URB %p failed, errno=%d. pProxyDev=%s!!!\n",
+                 pUrb, errno, usbProxyGetName(pProxyDev)));
     }
 }
@@ -1648 +1944 @@
  * The Linux USB Proxy Backend.
  */
-#ifdef __cplusplus
-extern
-#endif
 const USBPROXYBACK g_USBProxyDeviceHost =
 {
     "host",
     usbProxyLinuxOpen,
+    usbProxyLinuxInit,
     usbProxyLinuxClose,
     usbProxyLinuxReset,

trunk/src/VBox/RDP/client/vrdp/rdpusb.c

@@ -24 +24 @@
 #include <fcntl.h>
 
+#include "runtime.h"
 #include "vrdpusb.h"
+#include "USBProxyDevice.h"
 
 #define RDPUSB_REQ_OPEN              (0)
@@ -64 +66 @@
 #pragma pack ()
 
+static inline int op_usbproxy_back_open(PUSBPROXYDEV p, const char *pszAddress)
+{
+     return g_USBProxyDeviceHost.pfnOpen (p, pszAddress, NULL);
+}
+
+static inline void op_usbproxy_back_close(PUSBPROXYDEV pDev)
+{
+     return g_USBProxyDeviceHost.pfnClose (pDev);
+}
+
+static inline int op_usbproxy_back_reset(PUSBPROXYDEV pDev)
+{
+    return g_USBProxyDeviceHost.pfnReset (pDev, false);
+}
+
+static inline int op_usbproxy_back_set_config(PUSBPROXYDEV pDev, int cfg)
+{
+    return g_USBProxyDeviceHost.pfnSetConfig (pDev, cfg);
+}
+
+static inline int op_usbproxy_back_claim_interface(PUSBPROXYDEV pDev, int ifnum)
+{
+    return g_USBProxyDeviceHost.pfnClaimInterface (pDev, ifnum);
+}
+
+static inline int op_usbproxy_back_release_interface(PUSBPROXYDEV pDev, int ifnum)
+{
+    return g_USBProxyDeviceHost.pfnReleaseInterface (pDev, ifnum);
+}
+
+static inline int op_usbproxy_back_interface_setting(PUSBPROXYDEV pDev, int ifnum, int setting)
+{
+    return g_USBProxyDeviceHost.pfnSetInterface (pDev, ifnum, setting);
+}
+
+static inline int op_usbproxy_back_queue_urb(PVUSBURB pUrb)
+{
+    return g_USBProxyDeviceHost.pfnUrbQueue(pUrb);
+}
+
+static inline PVUSBURB op_usbproxy_back_reap_urb(PUSBPROXYDEV pDev, unsigned cMillies)
+{
+    return g_USBProxyDeviceHost.pfnUrbReap (pDev, cMillies);
+}
+
+static inline bool op_usbproxy_back_clear_halted_ep(PUSBPROXYDEV pDev, unsigned EndPoint)
+{
+    return g_USBProxyDeviceHost.pfnClearHaltedEndpoint (pDev, EndPoint);
+}
+
+static inline void op_usbproxy_back_cancel_urb(PVUSBURB pUrb)
+{
+    return g_USBProxyDeviceHost.pfnUrbCancel (pUrb);
+}
+
 static uint16 getBcd (const char *str, const char *prefix)
 {
@@ -405 +462 @@
 vrdp_usb_status (int rc, VUSBDEV *pdev)
 {
-        if (!rc || pdev->request_detach)
+        if (!rc || usbProxyFromVusbDev(pdev)->fDetached)
         {
                 return VRDP_USB_STATUS_DEVICE_REMOVED;
@@ -413 +470 @@
 }
 
-static struct usb_proxy *g_proxies = NULL;
-
-static struct usb_proxy *
+static PUSBPROXYDEV g_proxies = NULL;
+
+static PUSBPROXYDEV 
 devid2proxy (uint32_t devid)
 {
-        struct usb_proxy *proxy = g_proxies;
+        PUSBPROXYDEV proxy = g_proxies;
 
         while (proxy && proxy->devid != devid)
         {
-                proxy = proxy->next;
+                proxy = proxy->pNext;
         }
 
@@ -435 +492 @@
         PVUSBURB pUrb = NULL;
 
-        struct usb_proxy *proxy = g_proxies;
+        PUSBPROXYDEV proxy = g_proxies;
 
         while (proxy)
@@ -467 +524 @@
                         rdpusb_send(s);
 
-                        if (pUrb->prev || pUrb->next || pUrb == proxy->urbs)
+                        if (pUrb->pPrev || pUrb->pNext || pUrb == proxy->pUrbs)
                         {
                                 /* Remove the URB from list. */
-                                if (pUrb->prev)
-                                {
-                                        pUrb->prev->next = pUrb->next;
+                                if (pUrb->pPrev)
+                                {
+                                        pUrb->pPrev->pNext = pUrb->pNext;
                                 }
                                 else
                                 {
-                                        proxy->urbs = pUrb->next;
+                                        proxy->pUrbs = pUrb->pNext;
                                 }
 
-                                if (pUrb->next)
-                                {
-                                        pUrb->next->prev = pUrb->prev;
+                                if (pUrb->pNext)
+                                {
+                                        pUrb->pNext->pPrev = pUrb->pPrev;
                                 }
                         }
@@ -494 +551 @@
                 }
 
-                proxy = proxy->next;
+                proxy = proxy->pNext;
         }
 
@@ -509 +566 @@
         uint32 devid;
 
-        struct usb_proxy *proxy = NULL;
+        PUSBPROXYDEV proxy = NULL;
 
 #ifdef RDPUSB_DEBUG
@@ -535 +592 @@
                         in_uint32_le(s, devid);
 
-                        proxy = (struct usb_proxy *)xmalloc (sizeof (struct usb_proxy));
-
-                        memset (proxy, 0, sizeof (struct usb_proxy));
+                        proxy = (PUSBPROXYDEV )xmalloc (sizeof (USBPROXYDEV));
+
+                        memset (proxy, 0, sizeof (USBPROXYDEV));
 
                         proxy->Dev.pszName = "Remote device";
@@ -556 +613 @@
                                 if (g_proxies)
                                 {
-                                        g_proxies->prev = proxy;
+                                        g_proxies->pPrev = proxy;
                                 }
 
-                                proxy->next = g_proxies;
+                                proxy->pNext = g_proxies;
                                 g_proxies = proxy;
                         }
@@ -573 +630 @@
                                 op_usbproxy_back_close(proxy);
 
-                                if (proxy->prev)
-                                {
-                                        proxy->prev->next = proxy->next;
+                                if (proxy->pPrev)
+                                {
+                                        proxy->pPrev->pNext = proxy->pNext;
                                 }
                                 else
                                 {
-                                        g_proxies = proxy->next;
+                                        g_proxies = proxy->pNext;
                                 }
 
-                                if (proxy->next)
-                                {
-                                        proxy->next->prev = proxy->prev;
+                                if (proxy->pNext)
+                                {
+                                        proxy->pNext->pPrev = proxy->pPrev;
                                 }
 
@@ -760 +817 @@
                         if (rc)
                         {
-                                if (proxy->urbs)
-                                {
-                                        proxy->urbs->prev = pUrb;
+                                if (proxy->pUrbs)
+                                {
+                                        proxy->pUrbs->pPrev = pUrb;
                                 }
 
-                                pUrb->next = proxy->urbs;
-                                proxy->urbs = pUrb;
+                                pUrb->pNext = proxy->pUrbs;
+                                proxy->pUrbs = pUrb;
                         }
                         else
@@ -818 +875 @@
                         in_uint32_le(s, handle);
 
-                        pUrb = proxy->urbs;
+                        pUrb = proxy->pUrbs;
 
                         while (pUrb && pUrb->handle != handle)
                         {
-                                pUrb = pUrb->next;
+                                pUrb = pUrb->pNext;
                         }
 
@@ -832 +889 @@
 
                                 /* Remove URB from list. */
-                                if (pUrb->prev)
-                                {
-                                        pUrb->prev->next = pUrb->next;
+                                if (pUrb->pPrev)
+                                {
+                                        pUrb->pPrev->pNext = pUrb->pNext;
                                 }
                                 else
                                 {
-                                        proxy->urbs = pUrb->next;
+                                        proxy->pUrbs = pUrb->pNext;
                                 }
 
-                                if (pUrb->next)
-                                {
-                                        pUrb->next->prev = pUrb->prev;
+                                if (pUrb->pNext)
+                                {
+                                        pUrb->pNext->pPrev = pUrb->pPrev;
                                 }
 
-                                pUrb->next = pUrb->prev = NULL;
+                                pUrb->pNext = pUrb->pPrev = NULL;
 
                                 Log(("Cancelled URB %p\n", pUrb));
@@ -896 +953 @@
 rdpusb_add_fds(int *n, fd_set * rfds, fd_set * wfds)
 {
-        struct usb_proxy *proxy = g_proxies;
+        PUSBPROXYDEV proxy = g_proxies;
 
 //      Log(("RDPUSB: rdpusb_add_fds: begin *n = %d\n", *n));
@@ -902 +959 @@
         while (proxy)
         {
-                int fd = dev2fd(proxy);
+                int fd = USBProxyDeviceLinuxGetFD(proxy);
 
                 if (fd != -1)
@@ -913 +970 @@
                 }
 
-                proxy = proxy->next;
+                proxy = proxy->pNext;
         }
 
@@ -924 +981 @@
 rdpusb_check_fds(fd_set * rfds, fd_set * wfds)
 {
-        (void)rfds;
-        (void)wfds;
+        PUSBPROXYDEV proxy = g_proxies;
+        unsigned found = 0;
+
+        while (proxy)
+        {
+                int fd = USBProxyDeviceLinuxGetFD(proxy);
+
+                if (fd != -1)
+                {
+                        if (FD_ISSET(fd, rfds))
+                found = 1;
+                        if (FD_ISSET(fd, wfds))
+                found = 1;
+                }
+
+                proxy = proxy->pNext;
+        }
 
 //      Log(("RDPUSB: rdpusb_check_fds: begin\n"));
 
-        rdpusb_reap_urbs ();
+        if (found)
+        rdpusb_reap_urbs ();
 
 //      Log(("RDPUSB: rdpusb_check_fds: end\n"));
@@ -948 +1021 @@
 rdpusb_close (void)
 {
-        struct usb_proxy *proxy = g_proxies;
+        PUSBPROXYDEV proxy = g_proxies;
 
         while (proxy)
         {
-                struct usb_proxy *next = proxy->next;
+                PUSBPROXYDEV pNext = proxy->pNext;
 
                 Log(("RDPUSB: closing proxy %p\n", proxy));
@@ -959 +1032 @@
                 xfree (proxy);
 
-                proxy = next;
+                proxy = pNext;
         }
 

trunk/src/VBox/RDP/client/vrdp/runtime.h

@@ -15 +15 @@
  */
 
-#ifndef __VRDPUSB__H
-#define __VRDPUSB__H
+#ifndef __RUNTIME__H
+#define __RUNTIME__H
 
 #include <endian.h>
 #include <byteswap.h>
+#include <stdint.h>
+#include <ctype.h>
+#include <errno.h>
 
 #ifndef cpu_to_le16
@@ -34 +37 @@
 //#define cpu_to_le16 __cpu_to_le16
 
+#if 0
 #define uint8_t uint8
 #define uint16_t uint16
 #define uint32_t uint32
 #define uint64_t long long
+#endif
 #define bool int
 #define false 0
@@ -43 +48 @@
 
 #define OPSTATIC
+#define RDPUSB_DEBUG
 #ifdef RDPUSB_DEBUG
-#define LogFlow(a) printf a
-#define Log(a) printf a
-#define Log2(a) printf a
+#define DoLog(a) do { \
+        printf("Time %llu: ", RTTimeMilliTS()); \
+        printf a; \
+} while(0)
+
+#define LogFlow(a) DoLog(a)
+#define Log(a) DoLog(a)
+#define Log2(a) DoLog(a)
 #else
 #define LogFlow(a) do {} while (0)
@@ -62 +73 @@
 #define _1K 1024
 
-#define RT_LE2H_U16(_le16) (cpu_to_le16 (_le16))
+#ifdef RT_BIG_ENDIAN
+# define RT_H2LE_U16(u16)   RT_BSWAP_U16(u16)
+# define RT_LE2H_U16(u16)   RT_BSWAP_U16(u16)
+#else
+# define RT_H2LE_U16(u16)   (u16)
+# define RT_LE2H_U16(u16)   (u16)
+#endif
+#define RT_BSWAP_U16(u16) RT_MAKE_U16(RT_HIBYTE(u16), RT_LOBYTE(u16))
+#define RT_MAKE_U16(Lo, Hi) \
+    ((uint16_t)(  (uint16_t)((uint8_t)(Hi)) << 8 \
+                | (uint8_t)(Lo) ))
+#define RT_LOBYTE(a)                            ( (a) & 0xff )
+#define RT_HIBYTE(a)                            ( (a) >> 8 )
 
 #define VINF_SUCCESS 0
-#define VERR_NO_MEMORY     (-8)
-#define VERR_NOT_SUPPORTED (-37)
-#define VERR_ACCESS_DENIED (-38)
+#define VERR_NO_MEMORY        (-8)
+#define VERR_UNRESOLVED_ERROR (-35)
+#define VERR_NOT_SUPPORTED    (-37)
+#define VERR_ACCESS_DENIED    (-38)
 #define VERR_VUSB_USBFS_PERMISSION (-2005)
+
+static inline int RTErrConvertFromErrno(int iErrno)
+{
+    return   iErrno == 0 ? VINF_SUCCESS
+           : iErrno == ENOMEM ? VERR_NO_MEMORY
+           : iErrno == ENODEV ? VERR_NOT_SUPPORTED
+           : iErrno == ENOSYS ? VERR_NOT_SUPPORTED
+           : iErrno == EPERM ? VERR_ACCESS_DENIED
+           : iErrno == EACCES ? VERR_ACCESS_DENIED
+           : VERR_UNRESOLVED_ERROR;
+}
 
 #define RT_SUCCESS(_rc) ((_rc) >= 0)
@@ -101 +136 @@
 #define NOREF(_a) ((void)_a)
 
-static inline int RTCritSectInit (RTCRITSECT *pCritSect)
-{
-    return VINF_SUCCESS;
-}
-
-static inline int RTCritSectDelete (RTCRITSECT *pCritSect)
-{
-    return VINF_SUCCESS;
-}
-
-static inline int RTCritSectEnter (RTCRITSECT *pCritSect)
-{
-    return VINF_SUCCESS;
-}
-
-static inline int RTCritSectLeave (RTCRITSECT *pCritSect)
-{
-    return VINF_SUCCESS;
-}
-
-static inline void *RTMemDupEx (const void *pvSrc, size_t cbSrc, size_t cbExtra)
-{
-    void *p = RTMemAlloc (cbSrc + cbExtra);
-
-    if (p)
-    {
-         memcpy (p, pvSrc, cbSrc);
-         memset ((char *)p + cbSrc, 0, cbExtra);
-    }
-
-    return p;
-}
-
-static inline void *RTMemAllocZ (size_t cb)
-{
-    void *p = RTMemAlloc (cb);
-
-    if (p)
-    {
-         memset (p, 0, cb);
-    }
-
-    return p;
-}
-
-static inline int RTStrToUInt32Ex (const char *pszValue, char **ppszNext, unsigned uBase, uint32_t *pu32)
-{
-    *pu32 = strtoul (pszValue, ppszNext, uBase);
-    return VINF_SUCCESS;
-}
-
-#define PRTSTREAM FILE *
-
-static inline int RTStrmOpen (const char *pszFileName, const char *pszMode, PRTSTREAM *ppStream)
-{
-    *ppStream = fopen (pszFileName, pszMode);
-
-    if (*ppStream)
-    {
-        return VINF_SUCCESS;
-    }
-
-    return VERR_NOT_SUPPORTED;
-}
-
-static inline int RTStrmClose (PRTSTREAM pStream)
-{
-    fclose (pStream);
-    return VINF_SUCCESS;
-}
-
-static inline int RTStrmGetLine (PRTSTREAM pStream, char *pszString, size_t cchString)
-{
-    if (fgets (pszString, cchString, pStream))
-    {
-        return VINF_SUCCESS;
-    }
-
-    return VERR_NOT_SUPPORTED;
-}
-
-static inline char *RTStrStripL (const char *psz)
-{
-    while (isspace (*psz))
-        psz++;
-    return (char *)psz;
-}
-
-#define NIL_RTFILE -1
-
-#define RTFILE_O_READWRITE 0x00000003
-#define RTFILE_O_OPEN      0x00000000
-#define RTFILE_O_DENY_NONE 0x00000000
-
-static inline int RTFileOpen (RTFILE *pFile, const char *pszFileName, unsigned fOpen)
-{
-    Assert (fOpen == RTFILE_O_READWRITE);
-
-    *pFile = open (pszFileName, O_RDWR, 00600);
-
-    if (*pFile != -1)
-    {
-        return VINF_SUCCESS;
-    }
-
-    return VERR_ACCESS_DENIED;
-}
-
-static inline int RTFileClose (RTFILE file)
-{
-    close (file);
-    return VINF_SUCCESS;
-}
+#define RT_C_DECLS_BEGIN
+#define RT_C_DECLS_END
+
+#define RTCALL
+#define DECLR3CALLBACKMEMBER(type, name, args)  type (RTCALL * name) args
+#define DECLINLINE(type) static __inline__ type
+#define DECLCALLBACK(type)      type RTCALL
+#define DECLCALLBACKMEMBER(type, name)  type (RTCALL * name)
+#define RTDECL(type)       RTCALL type
+
+#define RT_BIT(bit)                             ( 1U << (bit) )
+#define RT_MAX(Value1, Value2)                  ( (Value1) >= (Value2) ? (Value1) : (Value2) )
+#define RT_MIN(Value1, Value2)                  ( (Value1) <= (Value2) ? (Value1) : (Value2) )
+typedef uint32_t            RTGCPHYS32;
+typedef uint32_t            RTMSINTERVAL;
 
 static inline uint64_t RTTimeMilliTS (void)
@@ -223 +160 @@
 }
 
-#define VRDP_USB_STATUS_SUCCESS         0
-#define VRDP_USB_STATUS_ACCESS_DENIED   1
-#define VRDP_USB_STATUS_DEVICE_REMOVED  2
-
-#define VRDP_USB_REAP_FLAG_CONTINUED (0)
-#define VRDP_USB_REAP_FLAG_LAST      (1)
-
-#define VRDP_USB_CAPS_FLAG_ASYNC    (0)
-#define VRDP_USB_CAPS_FLAG_POLL     (1)
-
-#pragma pack(1)
-
-#include "vusb.h"
-
-typedef struct VUSBDEV
-{
-        char* pszName;
-        int request_detach;
-} VUSBDEV, *PVUSBDEV;
-
-typedef struct usb_proxy {
-    /* Note: the backend code assumes that the dev member is the first in the structure. */
-    VUSBDEV Dev;
-    /* 'union' because backend accesses the file handle as priv.File. */
-    union {
-        void *pv;
-        int File;
-    } Backend;
-
-    struct usb_proxy *next;
-    struct usb_proxy *prev;
-
-    uint32_t devid;
-
-    PVUSBURB urbs;
-
-    int iActiveCfg;
-    int cIgnoreSetConfigs;
-} *PUSBPROXYDEV;
-
-typedef struct vusb_setup {
-        uint8_t  bmRequestType;
-        uint8_t  bRequest;
-        uint16_t wValue;
-        uint16_t wIndex;
-        uint16_t wLength;
-} VUSBSETUP, *PVUSBSETUP;
-#pragma pack()
-
-
-static inline void vusbDevUnplugged(PVUSBDEV dev)
-{
-        dev->request_detach = 1;
-}
-
-int dev2fd (PUSBPROXYDEV pProxyDev);
-
-
-typedef struct USBPROXYBACK
-{
-    /** Name of the backend. */
-    const char *pszName;
-
-    int  (* pfnOpen)(PUSBPROXYDEV pProxyDev, const char *pszAddress, void *pvBackend);
-    void (* pfnClose)(PUSBPROXYDEV pProxyDev);
-    int  (* pfnReset)(PUSBPROXYDEV pProxyDev);
-    int  (* pfnSetConfig)(PUSBPROXYDEV pProxyDev, int iCfg);
-    int  (* pfnClaimInterface)(PUSBPROXYDEV pProxyDev, int iIf);
-    int  (* pfnReleaseInterface)(PUSBPROXYDEV pProxyDev, int iIf);
-    int  (* pfnSetInterface)(PUSBPROXYDEV pProxyDev, int iIf, int setting);
-    bool (* pfnClearHaltedEndpoint)(PUSBPROXYDEV  pDev, unsigned int iEp);
-    int  (* pfnUrbQueue)(PVUSBURB urb);
-    void (* pfnUrbCancel)(PVUSBURB pUrb);
-    PVUSBURB (* pfnUrbReap)(PUSBPROXYDEV pProxyDev, unsigned cMillies);
-    uint32_t uDummy;
-} USBPROXYBACK;
-
-typedef USBPROXYBACK *PUSBPROXYBACK;
-
-extern const USBPROXYBACK g_USBProxyDeviceHost;
-
-static inline int op_usbproxy_back_open(struct usb_proxy *p, const char *pszAddress)
-{
-     return g_USBProxyDeviceHost.pfnOpen (p, pszAddress, NULL);
-}
-
-static inline void op_usbproxy_back_close(PUSBPROXYDEV pDev)
-{
-     return g_USBProxyDeviceHost.pfnClose (pDev);
-}
-
-static inline int op_usbproxy_back_reset(PUSBPROXYDEV pDev)
-{
-    return g_USBProxyDeviceHost.pfnReset (pDev);
-}
-
-static inline int op_usbproxy_back_set_config(PUSBPROXYDEV pDev, int cfg)
-{
-    return g_USBProxyDeviceHost.pfnSetConfig (pDev, cfg);
-}
-
-static inline int op_usbproxy_back_claim_interface(PUSBPROXYDEV pDev, int ifnum)
-{
-    return g_USBProxyDeviceHost.pfnClaimInterface (pDev, ifnum);
-}
-
-static inline int op_usbproxy_back_release_interface(PUSBPROXYDEV pDev, int ifnum)
-{
-    return g_USBProxyDeviceHost.pfnReleaseInterface (pDev, ifnum);
-}
-
-static inline int op_usbproxy_back_interface_setting(PUSBPROXYDEV pDev, int ifnum, int setting)
-{
-    return g_USBProxyDeviceHost.pfnSetInterface (pDev, ifnum, setting);
-}
-
-static inline int op_usbproxy_back_queue_urb(PVUSBURB pUrb)
-{
-    return g_USBProxyDeviceHost.pfnUrbQueue(pUrb);
-}
-
-static inline PVUSBURB op_usbproxy_back_reap_urb(PUSBPROXYDEV pDev, unsigned cMillies)
-{
-    return g_USBProxyDeviceHost.pfnUrbReap (pDev, cMillies);
-}
-
-static inline bool op_usbproxy_back_clear_halted_ep(PUSBPROXYDEV pDev, unsigned EndPoint)
-{
-    return g_USBProxyDeviceHost.pfnClearHaltedEndpoint (pDev, EndPoint);
-}
-
-static inline void op_usbproxy_back_cancel_urb(PVUSBURB pUrb)
-{
-    return g_USBProxyDeviceHost.pfnUrbCancel (pUrb);
-}
-
-#endif /* __VRDPUSB__H  */
+static inline int RTCritSectInit (RTCRITSECT *pCritSect)
+{
+    return VINF_SUCCESS;
+}
+
+static inline int RTCritSectDelete (RTCRITSECT *pCritSect)
+{
+    return VINF_SUCCESS;
+}
+
+static inline int RTCritSectEnter (RTCRITSECT *pCritSect)
+{
+    return VINF_SUCCESS;
+}
+
+static inline int RTCritSectLeave (RTCRITSECT *pCritSect)
+{
+    return VINF_SUCCESS;
+}
+
+static inline void *RTMemDupEx (const void *pvSrc, size_t cbSrc, size_t cbExtra)
+{
+    void *p = RTMemAlloc (cbSrc + cbExtra);
+
+    if (p)
+    {
+         memcpy (p, pvSrc, cbSrc);
+         memset ((char *)p + cbSrc, 0, cbExtra);
+    }
+
+    return p;
+}
+
+static inline void *RTMemAllocZ (size_t cb)
+{
+    void *p = RTMemAlloc (cb);
+
+    if (p)
+    {
+         memset (p, 0, cb);
+    }
+
+    return p;
+}
+
+static inline void *RTMemAllocZVar (size_t cbUnaligned)
+{
+    return RTMemAllocZ(cbUnaligned);
+}
+
+static inline int RTStrToUInt32Ex (const char *pszValue, char **ppszNext, unsigned uBase, uint32_t *pu32)
+{
+    *pu32 = strtoul (pszValue, ppszNext, uBase);
+    return VINF_SUCCESS;
+}
+
+#define PRTSTREAM FILE *
+
+static inline int RTStrmOpen (const char *pszFileName, const char *pszMode, PRTSTREAM *ppStream)
+{
+    *ppStream = fopen (pszFileName, pszMode);
+
+    if (*ppStream)
+    {
+        return VINF_SUCCESS;
+    }
+
+    return VERR_NOT_SUPPORTED;
+}
+
+static inline int RTStrmClose (PRTSTREAM pStream)
+{
+    fclose (pStream);
+    return VINF_SUCCESS;
+}
+
+static inline int RTStrmGetLine (PRTSTREAM pStream, char *pszString, size_t cchString)
+{
+    if (fgets (pszString, cchString, pStream))
+    {
+        return VINF_SUCCESS;
+    }
+
+    return VERR_NOT_SUPPORTED;
+}
+
+static inline char *RTStrStripL (const char *psz)
+{
+    while (isspace (*psz))
+        psz++;
+    return (char *)psz;
+}
+
+#define NIL_RTFILE -1
+
+#define RTFILE_O_READWRITE 0x00000003
+#define RTFILE_O_OPEN      0x00000000
+#define RTFILE_O_DENY_NONE 0x00000000
+
+static inline int RTFileOpen (RTFILE *pFile, const char *pszFileName, unsigned fOpen)
+{
+    Assert (fOpen == RTFILE_O_READWRITE);
+
+    *pFile = open (pszFileName, O_RDWR, 00600);
+
+    if (*pFile != -1)
+    {
+        return VINF_SUCCESS;
+    }
+
+    return VERR_ACCESS_DENIED;
+}
+
+static inline int RTFileClose (RTFILE file)
+{
+    close (file);
+    return VINF_SUCCESS;
+}
+#endif /* __RUNTIME__H  */

trunk/src/VBox/RDP/client/vrdp/vrdpusb.h

@@ -18 +18 @@
 #define __VRDPUSB__H
 
-#include <endian.h>
-#include <byteswap.h>
-
-#ifndef cpu_to_le16
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-#define cpu_to_le16(_le16) (_le16)
-#elif __BYTE_ORDER == __BIG_ENDIAN
-#define cpu_to_le16(_le16) bswap_16(_le16)
-#else
-#error Unsupported host byte order!
-#endif
-#endif /* cpu_to_le16 */
-
-//#include <asm/byteorder.h>
-//#define cpu_to_le16 __cpu_to_le16
-
-#define uint8_t uint8
-#define uint16_t uint16
-#define uint32_t uint32
-#define uint64_t long long
-#define bool int
-#define false 0
-#define true 1
-
-#define OPSTATIC
-#ifdef RDPUSB_DEBUG
-#define LogFlow(a) printf a
-#define Log(a) printf a
-#define Log2(a) printf a
-#else
-#define LogFlow(a) do {} while (0)
-#define Log(a)     do {} while (0)
-#define Log2(a)    do {} while (0)
-#endif
-
-#define LogRel(a) printf a
-
-/* Runtime wrappers. */
-#define RTMemAlloc xmalloc
-#define RTMemRealloc xrealloc
-#define RTMemFree xfree
-
-#define _1K 1024
-
-#define RT_LE2H_U16(_le16) (cpu_to_le16 (_le16))
-
-#define VINF_SUCCESS 0
-#define VERR_NO_MEMORY     (-8)
-#define VERR_NOT_SUPPORTED (-37)
-#define VERR_ACCESS_DENIED (-38)
-#define VERR_VUSB_USBFS_PERMISSION (-2005)
-
-#define RT_SUCCESS(_rc) ((_rc) >= 0)
-
-#define RTFILE int
-#define RTCRITSECT void *
-
-#define Assert(_expr) do {                            \
-    if (!(_expr))                                     \
-    {                                                 \
-        Log(("Assertion failed: {%s}!!!\n", #_expr)); \
-    }                                                 \
-} while (0)
-
-#define AssertMsgFailed(_msg) do {                    \
-        Log(("Assertion failed msg:!!!\n"));          \
-        Log(_msg);                                    \
-} while (0)
-
-#define AssertReturn(_expr, _retval) do {             \
-    if (!(_expr))                                     \
-    {                                                 \
-        Log(("Assertion failed: {%s}, returning 0x%08X!!!\n", #_expr, _retval)); \
-        return (_retval);                             \
-    }                                                 \
-} while (0)
-
-#define AssertRC(_rc) Assert(RT_SUCCESS(_rc))
-
-#define RT_FAILURE(_rc) (!RT_SUCCESS(_rc))
-
-#define NOREF(_a) ((void)_a)
-
-static inline int RTCritSectInit (RTCRITSECT *pCritSect)
-{
-    return VINF_SUCCESS;
-}
-
-static inline int RTCritSectDelete (RTCRITSECT *pCritSect)
-{
-    return VINF_SUCCESS;
-}
-
-static inline int RTCritSectEnter (RTCRITSECT *pCritSect)
-{
-    return VINF_SUCCESS;
-}
-
-static inline int RTCritSectLeave (RTCRITSECT *pCritSect)
-{
-    return VINF_SUCCESS;
-}
-
-static inline void *RTMemDupEx (const void *pvSrc, size_t cbSrc, size_t cbExtra)
-{
-    void *p = RTMemAlloc (cbSrc + cbExtra);
-
-    if (p)
-    {
-         memcpy (p, pvSrc, cbSrc);
-         memset ((char *)p + cbSrc, 0, cbExtra);
-    }
-
-    return p;
-}
-
-static inline void *RTMemAllocZ (size_t cb)
-{
-    void *p = RTMemAlloc (cb);
-
-    if (p)
-    {
-         memset (p, 0, cb);
-    }
-
-    return p;
-}
-
-static inline int RTStrToUInt32Ex (const char *pszValue, char **ppszNext, unsigned uBase, uint32_t *pu32)
-{
-    *pu32 = strtoul (pszValue, ppszNext, uBase);
-    return VINF_SUCCESS;
-}
-
-#define PRTSTREAM FILE *
-
-static inline int RTStrmOpen (const char *pszFileName, const char *pszMode, PRTSTREAM *ppStream)
-{
-    *ppStream = fopen (pszFileName, pszMode);
-
-    if (*ppStream)
-    {
-        return VINF_SUCCESS;
-    }
-
-    return VERR_NOT_SUPPORTED;
-}
-
-static inline int RTStrmClose (PRTSTREAM pStream)
-{
-    fclose (pStream);
-    return VINF_SUCCESS;
-}
-
-static inline int RTStrmGetLine (PRTSTREAM pStream, char *pszString, size_t cchString)
-{
-    if (fgets (pszString, cchString, pStream))
-    {
-        return VINF_SUCCESS;
-    }
-
-    return VERR_NOT_SUPPORTED;
-}
-
-static inline char *RTStrStripL (const char *psz)
-{
-    while (isspace (*psz))
-        psz++;
-    return (char *)psz;
-}
-
-#define NIL_RTFILE -1
-
-#define RTFILE_O_READWRITE 0x00000003
-#define RTFILE_O_OPEN      0x00000000
-#define RTFILE_O_DENY_NONE 0x00000000
-
-static inline int RTFileOpen (RTFILE *pFile, const char *pszFileName, unsigned fOpen)
-{
-    Assert (fOpen == RTFILE_O_READWRITE);
-
-    *pFile = open (pszFileName, O_RDWR, 00600);
-
-    if (*pFile != -1)
-    {
-        return VINF_SUCCESS;
-    }
-
-    return VERR_ACCESS_DENIED;
-}
-
-static inline int RTFileClose (RTFILE file)
-{
-    close (file);
-    return VINF_SUCCESS;
-}
-
-static inline uint64_t RTTimeMilliTS (void)
-{
-     struct timeval tv;
-     gettimeofday (&tv, NULL);
-     return (uint64_t)tv.tv_sec * (uint64_t)(1000)
-            + (uint64_t)(tv.tv_usec / 1000);
-}
-
 #define VRDP_USB_STATUS_SUCCESS         0
 #define VRDP_USB_STATUS_ACCESS_DENIED   1
@@ -233 +28 @@
 #define VRDP_USB_CAPS_FLAG_POLL     (1)
 
-#pragma pack(1)
-
-#include "vusb.h"
-
-typedef struct VUSBDEV
-{
-        char* pszName;
-        int request_detach;
-} VUSBDEV, *PVUSBDEV;
-
-typedef struct usb_proxy {
-    /* Note: the backend code assumes that the dev member is the first in the structure. */
-    VUSBDEV Dev;
-    /* 'union' because backend accesses the file handle as priv.File. */
-    union {
-        void *pv;
-        int File;
-    } Backend;
-
-    struct usb_proxy *next;
-    struct usb_proxy *prev;
-
-    uint32_t devid;
-
-    PVUSBURB urbs;
-
-    int iActiveCfg;
-    int cIgnoreSetConfigs;
-} *PUSBPROXYDEV;
-
-typedef struct vusb_setup {
-        uint8_t  bmRequestType;
-        uint8_t  bRequest;
-        uint16_t wValue;
-        uint16_t wIndex;
-        uint16_t wLength;
-} VUSBSETUP, *PVUSBSETUP;
-#pragma pack()
-
-
-static inline void vusbDevUnplugged(PVUSBDEV dev)
-{
-        dev->request_detach = 1;
-}
-
-int dev2fd (PUSBPROXYDEV pProxyDev);
-
-
-typedef struct USBPROXYBACK
-{
-    /** Name of the backend. */
-    const char *pszName;
-
-    int  (* pfnOpen)(PUSBPROXYDEV pProxyDev, const char *pszAddress, void *pvBackend);
-    void (* pfnClose)(PUSBPROXYDEV pProxyDev);
-    int  (* pfnReset)(PUSBPROXYDEV pProxyDev);
-    int  (* pfnSetConfig)(PUSBPROXYDEV pProxyDev, int iCfg);
-    int  (* pfnClaimInterface)(PUSBPROXYDEV pProxyDev, int iIf);
-    int  (* pfnReleaseInterface)(PUSBPROXYDEV pProxyDev, int iIf);
-    int  (* pfnSetInterface)(PUSBPROXYDEV pProxyDev, int iIf, int setting);
-    bool (* pfnClearHaltedEndpoint)(PUSBPROXYDEV  pDev, unsigned int iEp);
-    int  (* pfnUrbQueue)(PVUSBURB urb);
-    void (* pfnUrbCancel)(PVUSBURB pUrb);
-    PVUSBURB (* pfnUrbReap)(PUSBPROXYDEV pProxyDev, unsigned cMillies);
-    uint32_t uDummy;
-} USBPROXYBACK;
-
-typedef USBPROXYBACK *PUSBPROXYBACK;
-
-extern const USBPROXYBACK g_USBProxyDeviceHost;
-
-static inline int op_usbproxy_back_open(struct usb_proxy *p, const char *pszAddress)
-{
-     return g_USBProxyDeviceHost.pfnOpen (p, pszAddress, NULL);
-}
-
-static inline void op_usbproxy_back_close(PUSBPROXYDEV pDev)
-{
-     return g_USBProxyDeviceHost.pfnClose (pDev);
-}
-
-static inline int op_usbproxy_back_reset(PUSBPROXYDEV pDev)
-{
-    return g_USBProxyDeviceHost.pfnReset (pDev);
-}
-
-static inline int op_usbproxy_back_set_config(PUSBPROXYDEV pDev, int cfg)
-{
-    return g_USBProxyDeviceHost.pfnSetConfig (pDev, cfg);
-}
-
-static inline int op_usbproxy_back_claim_interface(PUSBPROXYDEV pDev, int ifnum)
-{
-    return g_USBProxyDeviceHost.pfnClaimInterface (pDev, ifnum);
-}
-
-static inline int op_usbproxy_back_release_interface(PUSBPROXYDEV pDev, int ifnum)
-{
-    return g_USBProxyDeviceHost.pfnReleaseInterface (pDev, ifnum);
-}
-
-static inline int op_usbproxy_back_interface_setting(PUSBPROXYDEV pDev, int ifnum, int setting)
-{
-    return g_USBProxyDeviceHost.pfnSetInterface (pDev, ifnum, setting);
-}
-
-static inline int op_usbproxy_back_queue_urb(PVUSBURB pUrb)
-{
-    return g_USBProxyDeviceHost.pfnUrbQueue(pUrb);
-}
-
-static inline PVUSBURB op_usbproxy_back_reap_urb(PUSBPROXYDEV pDev, unsigned cMillies)
-{
-    return g_USBProxyDeviceHost.pfnUrbReap (pDev, cMillies);
-}
-
-static inline bool op_usbproxy_back_clear_halted_ep(PUSBPROXYDEV pDev, unsigned EndPoint)
-{
-    return g_USBProxyDeviceHost.pfnClearHaltedEndpoint (pDev, EndPoint);
-}
-
-static inline void op_usbproxy_back_cancel_urb(PVUSBURB pUrb)
-{
-    return g_USBProxyDeviceHost.pfnUrbCancel (pUrb);
-}
-
 #endif /* __VRDPUSB__H  */

trunk/src/VBox/RDP/client/vrdp/vusb.h

@@ -1 +1 @@
 /** @file
- *
+ * VUSB - VirtualBox USB. (DEV,VMM)
  */
 
@@ -13 +13 @@
  * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
  * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
- */
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+#ifndef ___VBox_vusb_h
+#define ___VBox_vusb_h
+
+#ifndef RDESKTOP
+# include <VBox/cdefs.h>
+# include <VBox/types.h>
+#else
+# include "runtime.h"
+#endif
+
+RT_C_DECLS_BEGIN
+
+/** @defgroup grp_vusb  VBox USB API
+ * @{
+ */
+
+/** @defgroup grp_vusb_std  Standard Stuff
+ * @{ */
+
+/** Frequency of USB bus (from spec). */
+#define VUSB_BUS_HZ                 12000000
+
+
+/** @name USB Descriptor types (from spec)
+ * @{ */
+#define VUSB_DT_DEVICE                  0x01
+#define VUSB_DT_CONFIG                  0x02
+#define VUSB_DT_STRING                  0x03
+#define VUSB_DT_INTERFACE               0x04
+#define VUSB_DT_ENDPOINT                0x05
+#define VUSB_DT_DEVICE_QUALIFIER        0x06
+#define VUSB_DT_OTHER_SPEED_CFG         0x07
+#define VUSB_DT_INTERFACE_POWER         0x08
+/** @} */
+
+/** @name USB Descriptor minimum sizes (from spec)
+ * @{ */
+#define VUSB_DT_DEVICE_MIN_LEN          18
+#define VUSB_DT_CONFIG_MIN_LEN          9
+#define VUSB_DT_CONFIG_STRING_MIN_LEN   2
+#define VUSB_DT_INTERFACE_MIN_LEN       9
+#define VUSB_DT_ENDPOINT_MIN_LEN        7
+/** @} */
+
+
+#pragma pack(1) /* ensure byte packing of the descriptors. */
+
+/**
+ * USB language id descriptor (from specs).
+ */
+typedef struct VUSBDESCLANGID
+{
+    uint8_t bLength;
+    uint8_t bDescriptorType;
+} VUSBDESCLANGID;
+/** Pointer to a USB language id descriptor. */
+typedef VUSBDESCLANGID *PVUSBDESCLANGID;
+/** Pointer to a const USB language id descriptor. */
+typedef const VUSBDESCLANGID *PCVUSBDESCLANGID;
+
+
+/**
+ * USB string descriptor (from specs).
+ */
+typedef struct VUSBDESCSTRING
+{
+    uint8_t bLength;
+    uint8_t bDescriptorType;
+} VUSBDESCSTRING;
+/** Pointer to a USB string descriptor. */
+typedef VUSBDESCSTRING *PVUSBDESCSTRING;
+/** Pointer to a const USB string descriptor. */
+typedef const VUSBDESCSTRING *PCVUSBDESCSTRING;
+
+
+/**
+ * USB device descriptor (from spec)
+ */
+typedef struct VUSBDESCDEVICE
+{
+    uint8_t  bLength;
+    uint8_t  bDescriptorType;
+    uint16_t bcdUSB;
+    uint8_t  bDeviceClass;
+    uint8_t  bDeviceSubClass;
+    uint8_t  bDeviceProtocol;
+    uint8_t  bMaxPacketSize0;
+    uint16_t idVendor;
+    uint16_t idProduct;
+    uint16_t bcdDevice;
+    uint8_t  iManufacturer;
+    uint8_t  iProduct;
+    uint8_t  iSerialNumber;
+    uint8_t  bNumConfigurations;
+} VUSBDESCDEVICE;
+/** Pointer to a USB device descriptor. */
+typedef VUSBDESCDEVICE *PVUSBDESCDEVICE;
+/** Pointer to a const USB device descriptor. */
+typedef const VUSBDESCDEVICE *PCVUSBDESCDEVICE;
+
+
+/**
+ * USB configuration descriptor (from spec).
+ */
+typedef struct VUSBDESCCONFIG
+{
+    uint8_t  bLength;
+    uint8_t  bDescriptorType;
+    uint16_t wTotalLength; /**< recalculated by VUSB when involved in URB. */
+    uint8_t  bNumInterfaces;
+    uint8_t  bConfigurationValue;
+    uint8_t  iConfiguration;
+    uint8_t  bmAttributes;
+    uint8_t  MaxPower;
+} VUSBDESCCONFIG;
+/** Pointer to a USB configuration descriptor. */
+typedef VUSBDESCCONFIG *PVUSBDESCCONFIG;
+/** Pointer to a readonly USB configuration descriptor. */
+typedef const VUSBDESCCONFIG *PCVUSBDESCCONFIG;
+
+
+/**
+ * USB interface descriptor (from spec)
+ */
+typedef struct VUSBDESCINTERFACE
+{
+    uint8_t  bLength;
+    uint8_t  bDescriptorType;
+    uint8_t  bInterfaceNumber;
+    uint8_t  bAlternateSetting;
+    uint8_t  bNumEndpoints;
+    uint8_t  bInterfaceClass;
+    uint8_t  bInterfaceSubClass;
+    uint8_t  bInterfaceProtocol;
+    uint8_t  iInterface;
+} VUSBDESCINTERFACE;
+/** Pointer to an USB interface descriptor. */
+typedef VUSBDESCINTERFACE *PVUSBDESCINTERFACE;
+/** Pointer to a const USB interface descriptor. */
+typedef const VUSBDESCINTERFACE *PCVUSBDESCINTERFACE;
+
+
+/**
+ * USB endpoint descriptor (from spec)
+ */
+typedef struct VUSBDESCENDPOINT
+{
+    uint8_t  bLength;
+    uint8_t  bDescriptorType;
+    uint8_t  bEndpointAddress;
+    uint8_t  bmAttributes;
+    uint16_t wMaxPacketSize;
+    uint8_t  bInterval;
+} VUSBDESCENDPOINT;
+/** Pointer to an USB endpoint descriptor. */
+typedef VUSBDESCENDPOINT *PVUSBDESCENDPOINT;
+/** Pointer to a const USB endpoint descriptor. */
+typedef const VUSBDESCENDPOINT *PCVUSBDESCENDPOINT;
+
+#pragma pack() /* end of the byte packing. */
+
+
+/**
+ * USB configuration descriptor, the parsed variant used by VUSB.
+ */
+typedef struct VUSBDESCCONFIGEX
+{
+    /** The USB descriptor data.
+     * @remark  The wTotalLength member is recalculated before the data is passed to the guest. */
+    VUSBDESCCONFIG Core;
+    /** Pointer to additional descriptor bytes following what's covered by VUSBDESCCONFIG. */
+    void *pvMore;
+    /** Pointer to an array of the interfaces referenced in the configuration.
+     * Core.bNumInterfaces in size. */
+    const struct VUSBINTERFACE *paIfs;
+} VUSBDESCCONFIGEX;
+/** Pointer to a parsed USB configuration descriptor. */
+typedef VUSBDESCCONFIGEX *PVUSBDESCCONFIGEX;
+/** Pointer to a const parsed USB configuration descriptor. */
+typedef const VUSBDESCCONFIGEX *PCVUSBDESCCONFIGEX;
+
+
+/**
+ * For tracking the alternate interface settings of a configuration.
+ */
+typedef struct VUSBINTERFACE
+{
+    /** Pointer to an array of interfaces. */
+    const struct VUSBDESCINTERFACEEX *paSettings;
+    /** The number of entries in the array. */
+    uint32_t cSettings;
+} VUSBINTERFACE;
+/** Pointer to a VUSBINTERFACE. */
+typedef VUSBINTERFACE *PVUSBINTERFACE;
+/** Pointer to a const VUSBINTERFACE. */
+typedef const VUSBINTERFACE *PCVUSBINTERFACE;
+
+
+/**
+ * USB interface descriptor, the parsed variant used by VUSB.
+ */
+typedef struct VUSBDESCINTERFACEEX
+{
+    /** The USB descriptor data. */
+    VUSBDESCINTERFACE Core;
+    /** Pointer to additional descriptor bytes following what's covered by VUSBDESCINTERFACE. */
+    const void *pvMore;
+    /** Pointer to additional class- or vendor-specific interface descriptors. */
+    const void *pvClass;
+    /** Size of class- or vendor-specific descriptors. */
+    uint16_t cbClass;
+    /** Pointer to an array of the endpoints referenced by the interface.
+     * Core.bNumEndpoints in size. */
+    const struct VUSBDESCENDPOINTEX *paEndpoints;
+} VUSBDESCINTERFACEEX;
+/** Pointer to an prased USB interface descriptor. */
+typedef VUSBDESCINTERFACEEX *PVUSBDESCINTERFACEEX;
+/** Pointer to a const parsed USB interface descriptor. */
+typedef const VUSBDESCINTERFACEEX *PCVUSBDESCINTERFACEEX;
+
+
+/**
+ * USB endpoint descriptor, the parsed variant used by VUSB.
+ */
+typedef struct VUSBDESCENDPOINTEX
+{
+    /** The USB descriptor data.
+     * @remark The wMaxPacketSize member is converted to native endian. */
+    VUSBDESCENDPOINT Core;
+    /** Pointer to additional descriptor bytes following what's covered by VUSBDESCENDPOINT. */
+    const void *pvMore;
+    /** Pointer to additional class- or vendor-specific interface descriptors. */
+    const void *pvClass;
+    /** Size of class- or vendor-specific descriptors. */
+    uint16_t cbClass;
+} VUSBDESCENDPOINTEX;
+/** Pointer to a parsed USB endpoint descriptor. */
+typedef VUSBDESCENDPOINTEX *PVUSBDESCENDPOINTEX;
+/** Pointer to a const parsed USB endpoint descriptor. */
+typedef const VUSBDESCENDPOINTEX *PCVUSBDESCENDPOINTEX;
+
+
+/** @name USB Control message recipient codes (from spec)
+ * @{ */
+#define VUSB_TO_DEVICE          0x0
+#define VUSB_TO_INTERFACE       0x1
+#define VUSB_TO_ENDPOINT        0x2
+#define VUSB_TO_OTHER           0x3
+#define VUSB_RECIP_MASK         0x1f
+/** @} */
+
+/** @name USB control pipe setup packet structure (from spec)
+ * @{ */
+#define VUSB_REQ_SHIFT          (5)
+#define VUSB_REQ_STANDARD       (0x0 << VUSB_REQ_SHIFT)
+#define VUSB_REQ_CLASS          (0x1 << VUSB_REQ_SHIFT)
+#define VUSB_REQ_VENDOR         (0x2 << VUSB_REQ_SHIFT)
+#define VUSB_REQ_RESERVED       (0x3 << VUSB_REQ_SHIFT)
+#define VUSB_REQ_MASK           (0x3 << VUSB_REQ_SHIFT)
+/** @} */
+
+#define VUSB_DIR_TO_DEVICE      0x00
+#define VUSB_DIR_TO_HOST        0x80
+#define VUSB_DIR_MASK           0x80
+
+/**
+ * USB Setup request (from spec)
+ */
+typedef struct vusb_setup
+{
+    uint8_t  bmRequestType;
+    uint8_t  bRequest;
+    uint16_t wValue;
+    uint16_t wIndex;
+    uint16_t wLength;
+} VUSBSETUP;
+/** Pointer to a setup request. */
+typedef VUSBSETUP *PVUSBSETUP;
+/** Pointer to a const setup request. */
+typedef const VUSBSETUP *PCVUSBSETUP;
+
+/** @name USB Standard device requests (from spec)
+ * @{ */
+#define VUSB_REQ_GET_STATUS         0x00
+#define VUSB_REQ_CLEAR_FEATURE      0x01
+#define VUSB_REQ_SET_FEATURE        0x03
+#define VUSB_REQ_SET_ADDRESS        0x05
+#define VUSB_REQ_GET_DESCRIPTOR     0x06
+#define VUSB_REQ_SET_DESCRIPTOR     0x07
+#define VUSB_REQ_GET_CONFIGURATION  0x08
+#define VUSB_REQ_SET_CONFIGURATION  0x09
+#define VUSB_REQ_GET_INTERFACE      0x0a
+#define VUSB_REQ_SET_INTERFACE      0x0b
+#define VUSB_REQ_SYNCH_FRAME        0x0c
+#define VUSB_REQ_MAX                0x0d
+/** @} */
+
+/** @} */ /* end of grp_vusb_std */
+
+
+
+/** @name USB Standard version flags.
+ * @{ */
+/** Indicates USB 1.1 support. */
+#define VUSB_STDVER_11              RT_BIT(1)
+/** Indicates USB 2.0 support. */
+#define VUSB_STDVER_20              RT_BIT(2)
+/** @} */
+
 
 /** Pointer to a VBox USB device interface. */
@@ -25 +344 @@
 
 
+
+/**
+ * VBox USB port bitmap.
+ *
+ * Bit 0 == Port 0, ... , Bit 127 == Port 127.
+ */
+typedef struct VUSBPORTBITMAP
+{
+    /** 128 bits */
+    char ach[16];
+} VUSBPORTBITMAP;
+/** Pointer to a VBox USB port bitmap. */
+typedef VUSBPORTBITMAP *PVUSBPORTBITMAP;
+
+#ifndef RDESKTOP
+
+/**
+ * The VUSB RootHub port interface provided by the HCI (down).
+ * Pair with VUSBIROOTCONNECTOR
+ */
+typedef struct VUSBIROOTHUBPORT
+{
+    /**
+     * Get the number of avilable ports in the hub.
+     *
+     * @returns The number of ports available.
+     * @param   pInterface      Pointer to this structure.
+     * @param   pAvailable      Bitmap indicating the available ports. Set bit == available port.
+     */
+    DECLR3CALLBACKMEMBER(unsigned, pfnGetAvailablePorts,(PVUSBIROOTHUBPORT pInterface, PVUSBPORTBITMAP pAvailable));
+
+    /**
+     * Gets the supported USB versions.
+     *
+     * @returns The mask of supported USB versions.
+     * @param   pInterface      Pointer to this structure.
+     */
+    DECLR3CALLBACKMEMBER(uint32_t, pfnGetUSBVersions,(PVUSBIROOTHUBPORT pInterface));
+
+    /**
+     * A device is being attached to a port in the roothub.
+     *
+     * @param   pInterface      Pointer to this structure.
+     * @param   pDev            Pointer to the device being attached.
+     * @param   uPort           The port number assigned to the device.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnAttach,(PVUSBIROOTHUBPORT pInterface, PVUSBIDEVICE pDev, unsigned uPort));
+
+    /**
+     * A device is being detached from a port in the roothub.
+     *
+     * @param   pInterface      Pointer to this structure.
+     * @param   pDev            Pointer to the device being detached.
+     * @param   uPort           The port number assigned to the device.
+     */
+    DECLR3CALLBACKMEMBER(void, pfnDetach,(PVUSBIROOTHUBPORT pInterface, PVUSBIDEVICE pDev, unsigned uPort));
+
+    /**
+     * Reset the root hub.
+     *
+     * @returns VBox status code.
+     * @param   pInterface      Pointer to this structure.
+     * @param   pResetOnLinux   Whether or not to do real reset on linux.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnReset,(PVUSBIROOTHUBPORT pInterface, bool fResetOnLinux));
+
+    /**
+     * Transfer completion callback routine.
+     *
+     * VUSB will call this when a transfer have been completed
+     * in a one or another way.
+     *
+     * @param   pInterface      Pointer to this structure.
+     * @param   pUrb            Pointer to the URB in question.
+     */
+    DECLR3CALLBACKMEMBER(void, pfnXferCompletion,(PVUSBIROOTHUBPORT pInterface, PVUSBURB urb));
+
+    /**
+     * Handle transfer errors.
+     *
+     * VUSB calls this when a transfer attempt failed. This function will respond
+     * indicating wheter to retry or complete the URB with failure.
+     *
+     * @returns Retry indicator.
+     * @param   pInterface      Pointer to this structure.
+     * @param   pUrb            Pointer to the URB in question.
+     */
+    DECLR3CALLBACKMEMBER(bool, pfnXferError,(PVUSBIROOTHUBPORT pInterface, PVUSBURB pUrb));
+
+    /** Alignment dummy. */
+    RTR3PTR Alignment;
+
+} VUSBIROOTHUBPORT;
+/** VUSBIROOTHUBPORT interface ID. */
+#define VUSBIROOTHUBPORT_IID                    "e38e2978-7aa2-4860-94b6-9ef4a066d8a0"
+
+
+/** Pointer to a VUSB RootHub connector interface. */
+typedef struct VUSBIROOTHUBCONNECTOR *PVUSBIROOTHUBCONNECTOR;
+/**
+ * The VUSB RootHub connector interface provided by the VBox USB RootHub driver
+ * (up).
+ * Pair with VUSBIROOTHUBPORT.
+ */
+typedef struct VUSBIROOTHUBCONNECTOR
+{
+    /**
+     * Allocates a new URB for a transfer.
+     *
+     * Either submit using pfnSubmitUrb or free using VUSBUrbFree().
+     *
+     * @returns Pointer to a new URB.
+     * @returns NULL on failure - try again later.
+     *          This will not fail if the device wasn't found. We'll fail it
+     *          at submit time, since that makes the usage of this api simpler.
+     * @param   pInterface  Pointer to this struct.
+     * @param   DstAddress  The destination address of the URB.
+     * @param   cbData      The amount of data space required.
+     * @param   cTds        The amount of TD space.
+     */
+    DECLR3CALLBACKMEMBER(PVUSBURB, pfnNewUrb,(PVUSBIROOTHUBCONNECTOR pInterface, uint8_t DstAddress, uint32_t cbData, uint32_t cTds));
+
+    /**
+     * Submits a URB for transfer.
+     * The transfer will do asynchronously if possible.
+     *
+     * @returns VBox status code.
+     * @param   pInterface  Pointer to this struct.
+     * @param   pUrb        Pointer to the URB returned by pfnNewUrb.
+     *                      The URB will be freed in case of failure.
+     * @param   pLed        Pointer to USB Status LED
+     */
+    DECLR3CALLBACKMEMBER(int, pfnSubmitUrb,(PVUSBIROOTHUBCONNECTOR pInterface, PVUSBURB pUrb, struct PDMLED *pLed));
+
+    /**
+     * Call to service asynchronous URB completions in a polling fashion.
+     *
+     * Reaped URBs will be finished by calling the completion callback,
+     * thus there is no return code or input or anything from this function
+     * except for potential state changes elsewhere.
+     *
+     * @returns VINF_SUCCESS if no URBs are pending upon return.
+     * @returns VERR_TIMEOUT if one or more URBs are still in flight upon returning.
+     * @returns Other VBox status code.
+     *
+     * @param   pInterface  Pointer to this struct.
+     * @param   cMillies    Number of milliseconds to poll for completion.
+     */
+    DECLR3CALLBACKMEMBER(void, pfnReapAsyncUrbs,(PVUSBIROOTHUBCONNECTOR pInterface, RTMSINTERVAL cMillies));
+
+    /**
+     * Cancels and completes - with CRC failure - all in-flight async URBs.
+     * This is typically done before saving a state.
+     *
+     * @param   pInterface  Pointer to this struct.
+     */
+    DECLR3CALLBACKMEMBER(void, pfnCancelAllUrbs,(PVUSBIROOTHUBCONNECTOR pInterface));
+
+    /**
+     * Attach the device to the root hub.
+     * The device must not be attached to any hub for this call to succeed.
+     *
+     * @returns VBox status code.
+     * @param   pInterface  Pointer to this struct.
+     * @param   pDevice     Pointer to the device (interface) attach.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnAttachDevice,(PVUSBIROOTHUBCONNECTOR pInterface, PVUSBIDEVICE pDevice));
+
+    /**
+     * Detach the device from the root hub.
+     * The device must already be attached for this call to succeed.
+     *
+     * @returns VBox status code.
+     * @param   pInterface  Pointer to this struct.
+     * @param   pDevice     Pointer to the device (interface) to detach.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnDetachDevice,(PVUSBIROOTHUBCONNECTOR pInterface, PVUSBIDEVICE pDevice));
+
+} VUSBIROOTHUBCONNECTOR;
+/** VUSBIROOTHUBCONNECTOR interface ID. */
+#define VUSBIROOTHUBCONNECTOR_IID               "d9a90c59-e3ff-4dff-9754-844557c3f7a0"
+
+
+#ifdef IN_RING3
+/** @copydoc VUSBIROOTHUBCONNECTOR::pfnNewUrb */
+DECLINLINE(PVUSBURB) VUSBIRhNewUrb(PVUSBIROOTHUBCONNECTOR pInterface, uint32_t DstAddress, uint32_t cbData, uint32_t cTds)
+{
+    return pInterface->pfnNewUrb(pInterface, DstAddress, cbData, cTds);
+}
+
+/** @copydoc VUSBIROOTHUBCONNECTOR::pfnSubmitUrb */
+DECLINLINE(int) VUSBIRhSubmitUrb(PVUSBIROOTHUBCONNECTOR pInterface, PVUSBURB pUrb, struct PDMLED *pLed)
+{
+    return pInterface->pfnSubmitUrb(pInterface, pUrb, pLed);
+}
+
+/** @copydoc VUSBIROOTHUBCONNECTOR::pfnReapAsyncUrbs */
+DECLINLINE(void) VUSBIRhReapAsyncUrbs(PVUSBIROOTHUBCONNECTOR pInterface, RTMSINTERVAL cMillies)
+{
+    pInterface->pfnReapAsyncUrbs(pInterface, cMillies);
+}
+
+/** @copydoc VUSBIROOTHUBCONNECTOR::pfnCancelAllUrbs */
+DECLINLINE(void) VUSBIRhCancelAllUrbs(PVUSBIROOTHUBCONNECTOR pInterface)
+{
+    pInterface->pfnCancelAllUrbs(pInterface);
+}
+
+/** @copydoc VUSBIROOTHUBCONNECTOR::pfnAttachDevice */
+DECLINLINE(int) VUSBIRhAttachDevice(PVUSBIROOTHUBCONNECTOR pInterface, PVUSBIDEVICE pDevice)
+{
+    return pInterface->pfnAttachDevice(pInterface, pDevice);
+}
+
+/** @copydoc VUSBIROOTHUBCONNECTOR::pfnDetachDevice */
+DECLINLINE(int) VUSBIRhDetachDevice(PVUSBIROOTHUBCONNECTOR pInterface, PVUSBIDEVICE pDevice)
+{
+    return pInterface->pfnDetachDevice(pInterface, pDevice);
+}
+#endif /* IN_RING3 */
+
+
+
+/** Pointer to a Root Hub Configuration Interface. */
+typedef struct VUSBIRHCONFIG *PVUSBIRHCONFIG;
+/**
+ * Root Hub Configuration Interface (intended for MAIN).
+ * No interface pair.
+ */
+typedef struct VUSBIRHCONFIG
+{
+    /**
+     * Creates a USB proxy device and attaches it to the root hub.
+     *
+     * @returns VBox status code.
+     * @param   pInterface      Pointer to the root hub configuration interface structure.
+     * @param   pUuid           Pointer to the UUID for the new device.
+     * @param   fRemote         Whether the device must use the VRDP backend.
+     * @param   pszAddress      OS specific device address.
+     * @param   pvBackend       An opaque pointer for the backend. Only used by
+     *                          the VRDP backend so far.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnCreateProxyDevice,(PVUSBIRHCONFIG pInterface, PCRTUUID pUuid, bool fRemote, const char *pszAddress, void *pvBackend));
+
+    /**
+     * Removes a USB proxy device from the root hub and destroys it.
+     *
+     * @returns VBox status code.
+     * @param   pInterface      Pointer to the root hub configuration interface structure.
+     * @param   pUuid           Pointer to the UUID for the device.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnDestroyProxyDevice,(PVUSBIRHCONFIG pInterface, PCRTUUID pUuid));
+
+} VUSBIRHCONFIG;
+/** VUSBIRHCONFIG interface ID. */
+#define VUSBIRHCONFIG_IID                       "c354cd97-e85f-465e-bc12-b58798465f52"
+
+
+#ifdef IN_RING3
+/** @copydoc  VUSBIRHCONFIG::pfnCreateProxyDevice */
+DECLINLINE(int) VUSBIRhCreateProxyDevice(PVUSBIRHCONFIG pInterface, PCRTUUID pUuid, bool fRemote, const char *pszAddress, void *pvBackend)
+{
+    return pInterface->pfnCreateProxyDevice(pInterface, pUuid, fRemote, pszAddress, pvBackend);
+}
+
+/** @copydoc VUSBIRHCONFIG::pfnDestroyProxyDevice */
+DECLINLINE(int) VUSBIRhDestroyProxyDevice(PVUSBIRHCONFIG pInterface, PCRTUUID pUuid)
+{
+    return pInterface->pfnDestroyProxyDevice(pInterface, pUuid);
+}
+#endif /* IN_RING3 */
+
+#endif /* ! RDESKTOP */
+
+
+/**
+ * VUSB device reset completion callback function.
+ * This is called by the reset thread when the reset has been completed.
+ *
+ * @param   pDev        Pointer to the virtual USB device core.
+ * @param   rc      The VBox status code of the reset operation.
+ * @param   pvUser      User specific argument.
+ *
+ * @thread  The reset thread or EMT.
+ */
+typedef DECLCALLBACK(void) FNVUSBRESETDONE(PVUSBIDEVICE pDevice, int rc, void *pvUser);
+/** Pointer to a device reset completion callback function (FNUSBRESETDONE). */
+typedef FNVUSBRESETDONE *PFNVUSBRESETDONE;
+
+/**
+ * The state of a VUSB Device.
+ *
+ * @remark  The order of these states is vital.
+ */
+typedef enum VUSBDEVICESTATE
+{
+    VUSB_DEVICE_STATE_INVALID = 0,
+    VUSB_DEVICE_STATE_DETACHED,
+    VUSB_DEVICE_STATE_ATTACHED,
+    VUSB_DEVICE_STATE_POWERED,
+    VUSB_DEVICE_STATE_DEFAULT,
+    VUSB_DEVICE_STATE_ADDRESS,
+    VUSB_DEVICE_STATE_CONFIGURED,
+    VUSB_DEVICE_STATE_SUSPENDED,
+    /** The device is being reset. Don't mess with it.
+     * Next states: VUSB_DEVICE_STATE_DEFAULT, VUSB_DEVICE_STATE_DESTROYED
+     */
+    VUSB_DEVICE_STATE_RESET,
+    /** The device has been destroy. */
+    VUSB_DEVICE_STATE_DESTROYED,
+    /** The usual 32-bit hack. */
+    VUSB_DEVICE_STATE_32BIT_HACK = 0x7fffffff
+} VUSBDEVICESTATE;
+
+#ifndef RDESKTOP
+
+/**
+ * USB Device Interface (up).
+ * No interface pair.
+ */
+typedef struct VUSBIDEVICE
+{
+    /**
+     * Resets the device.
+     *
+     * Since a device reset shall take at least 10ms from the guest point of view,
+     * it must be performed asynchronously. We create a thread which performs this
+     * operation and ensures it will take at least 10ms.
+     *
+     * At times - like init - a synchronous reset is required, this can be done
+     * by passing NULL for pfnDone.
+     *
+     * -- internal stuff, move it --
+     * While the device is being reset it is in the VUSB_DEVICE_STATE_RESET state.
+     * On completion it will be in the VUSB_DEVICE_STATE_DEFAULT state if successful,
+     * or in the VUSB_DEVICE_STATE_DETACHED state if the rest failed.
+     * -- internal stuff, move it --
+     *
+     * @returns VBox status code.
+     * @param   pInterface      Pointer to this structure.
+     * @param   fResetOnLinux   Set if we can permit a real reset and a potential logical
+     *                          device reconnect on linux hosts.
+     * @param   pfnDone         Pointer to the completion routine. If NULL a synchronous
+     *                          reset  is preformed not respecting the 10ms.
+     * @param   pvUser          User argument to the completion routine.
+     * @param   pVM             Pointer to the VM handle if callback in EMT is required. (optional)
+     */
+    DECLR3CALLBACKMEMBER(int, pfnReset,(PVUSBIDEVICE pInterface, bool fResetOnLinux,
+                                        PFNVUSBRESETDONE pfnDone, void *pvUser, PVM pVM));
+
+    /**
+     * Powers on the device.
+     *
+     * @returns VBox status code.
+     * @param   pInterface      Pointer to the device interface structure.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnPowerOn,(PVUSBIDEVICE pInterface));
+
+    /**
+     * Powers off the device.
+     *
+     * @returns VBox status code.
+     * @param   pInterface      Pointer to the device interface structure.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnPowerOff,(PVUSBIDEVICE pInterface));
+
+    /**
+     * Get the state of the device.
+     *
+     * @returns Device state.
+     * @param   pInterface      Pointer to the device interface structure.
+     */
+    DECLR3CALLBACKMEMBER(VUSBDEVICESTATE, pfnGetState,(PVUSBIDEVICE pInterface));
+
+} VUSBIDEVICE;
+/** VUSBIDEVICE interface ID. */
+#define VUSBIDEVICE_IID                         "88732dd3-0ccd-4625-b040-48804ac7a217"
+
+
+#ifdef IN_RING3
+/**
+ * Resets the device.
+ *
+ * Since a device reset shall take at least 10ms from the guest point of view,
+ * it must be performed asynchronously. We create a thread which performs this
+ * operation and ensures it will take at least 10ms.
+ *
+ * At times - like init - a synchronous reset is required, this can be done
+ * by passing NULL for pfnDone.
+ *
+ * -- internal stuff, move it --
+ * While the device is being reset it is in the VUSB_DEVICE_STATE_RESET state.
+ * On completion it will be in the VUSB_DEVICE_STATE_DEFAULT state if successful,
+ * or in the VUSB_DEVICE_STATE_DETACHED state if the rest failed.
+ * -- internal stuff, move it --
+ *
+ * @returns VBox status code.
+ * @param   pInterface      Pointer to the device interface structure.
+ * @param   fResetOnLinux   Set if we can permit a real reset and a potential logical
+ *                          device reconnect on linux hosts.
+ * @param   pfnDone         Pointer to the completion routine. If NULL a synchronous
+ *                          reset  is preformed not respecting the 10ms.
+ * @param   pvUser          User argument to the completion routine.
+ * @param   pVM             Pointer to the VM handle if callback in EMT is required. (optional)
+ */
+DECLINLINE(int) VUSBIDevReset(PVUSBIDEVICE pInterface, bool fResetOnLinux, PFNVUSBRESETDONE pfnDone, void *pvUser, PVM pVM)
+{
+    return pInterface->pfnReset(pInterface, fResetOnLinux, pfnDone, pvUser, pVM);
+}
+
+/**
+ * Powers on the device.
+ *
+ * @returns VBox status code.
+ * @param   pInterface      Pointer to the device interface structure.
+ */
+DECLINLINE(int) VUSBIDevPowerOn(PVUSBIDEVICE pInterface)
+{
+    return pInterface->pfnPowerOn(pInterface);
+}
+
+/**
+ * Powers off the device.
+ *
+ * @returns VBox status code.
+ * @param   pInterface      Pointer to the device interface structure.
+ */
+DECLINLINE(int) VUSBIDevPowerOff(PVUSBIDEVICE pInterface)
+{
+    return pInterface->pfnPowerOff(pInterface);
+}
+
+/**
+ * Get the state of the device.
+ *
+ * @returns Device state.
+ * @param   pInterface      Pointer to the device interface structure.
+ */
+DECLINLINE(VUSBDEVICESTATE) VUSBIDevGetState(PVUSBIDEVICE pInterface)
+{
+    return pInterface->pfnGetState(pInterface);
+}
+#endif /* IN_RING3 */
+
+#endif /* ! RDESKTOP */
+
 /** @name URB
  * @{ */
@@ -35 +800 @@
     /** Transer was ok. */
     VUSBSTATUS_OK = 0,
-#define VUSB_XFER_OK    VUSBSTATUS_OK
     /** Transfer stalled, endpoint halted. */
     VUSBSTATUS_STALL,
-#define VUSB_XFER_STALL VUSBSTATUS_STALL
     /** Device not responding. */
     VUSBSTATUS_DNR,
-#define VUSB_XFER_DNR   VUSBSTATUS_DNR
     /** CRC error. */
     VUSBSTATUS_CRC,
-#define VUSB_XFER_CRC   VUSBSTATUS_CRC
-    /** Underflow error. */
-    VUSBSTATUS_UNDERFLOW,
+    /** Data overrun error. */
+    VUSBSTATUS_DATA_UNDERRUN,
+    /** Data overrun error. */
+    VUSBSTATUS_DATA_OVERRUN,
+    /** The isochronous buffer hasn't been touched. */
+    VUSBSTATUS_NOT_ACCESSED,
     /** Invalid status. */
     VUSBSTATUS_INVALID = 0x7f
@@ -59 +824 @@
     /** Control message. Used to represent a single control transfer. */
     VUSBXFERTYPE_CTRL = 0,
-#define VUSB_TRANSFER_TYPE_CTRL VUSBXFERTYPE_CTRL
     /* Isochronous transfer. */
     VUSBXFERTYPE_ISOC,
-#define VUSB_TRANSFER_TYPE_ISOC VUSBXFERTYPE_ISOC
     /** Bulk transfer. */
     VUSBXFERTYPE_BULK,
-#define VUSB_TRANSFER_TYPE_BULK VUSBXFERTYPE_BULK
     /** Interrupt transfer. */
     VUSBXFERTYPE_INTR,
-#define VUSB_TRANSFER_TYPE_INTR VUSBXFERTYPE_INTR
     /** Complete control message. Used to represent an entire control message. */
     VUSBXFERTYPE_MSG,
-#define VUSB_TRANSFER_TYPE_MSG  VUSBXFERTYPE_MSG
     /** Invalid transfer type. */
     VUSBXFERTYPE_INVALID = 0x7f
@@ -90 +850 @@
     /** Out - Host to device. */
     VUSBDIRECTION_OUT = 2,
-#define VUSB_DIRECTION_OUT      VUSBDIRECTION_OUT
+#define VUSB_DIRECTION_OUT  VUSBDIRECTION_OUT
     /** Invalid direction */
     VUSBDIRECTION_INVALID = 0x7f
@@ -125 +885 @@
 
 /**
+ * Information about a isochronous packet.
+ */
+typedef struct VUSBURBISOCPKT
+{
+    /** The size of the packet.
+     * IN: The packet size. I.e. the number of bytes to the next packet or end of buffer.
+     * OUT: The actual size transfered. */
+    uint16_t        cb;
+    /** The offset of the packet. (Relative to VUSBURB::abData[0].)
+     * OUT: This can be changed by the USB device if it does some kind of buffer squeezing. */
+    uint16_t        off;
+    /** The status of the transfer.
+     * IN: VUSBSTATUS_INVALID
+     * OUT: VUSBSTATUS_INVALID if nothing was done, otherwise the correct status. */
+    VUSBSTATUS      enmStatus;
+} VUSBURBISOCPKT;
+/** Pointer to a isochronous packet. */
+typedef VUSBURBISOCPKT *PVUSBURBISOCPTK;
+/** Pointer to a const isochronous packet. */
+typedef const VUSBURBISOCPKT *PCVUSBURBISOCPKT;
+
+/**
  * Asynchronous USB request descriptor
  */
@@ -133 +915 @@
     /** The USR state. */
     VUSBURBSTATE    enmState;
-
-    /* Private fields not accessed by the backend. */
-    PVUSBURB        next;
-    PVUSBURB        prev;
+    /** URB description, can be null. intended for logging. */
+    char           *pszDesc;
+
+#ifdef RDESKTOP
+    /** The next URB in rdesktop-vrdp's linked list */
+    PVUSBURB        pNext;
+    /** The previous URB in rdesktop-vrdp's linked list */
+    PVUSBURB        pPrev;
+    /** The vrdp handle for the URB */
     uint32_t        handle;
+    /** Pointer used to find the usb proxy device */
+    struct VUSBDEV *pDev;
+#endif
 
     /** The VUSB data. */
@@ -148 +938 @@
         /** Pointer to the original for control messages. */
         PVUSBURB        pCtrlUrb;
+        /** Pointer to the VUSB device.
+         * This may be NULL if the destination address is invalid. */
+        struct VUSBDEV *pDev;
         /** Sepcific to the pfnFree function. */
         void           *pvFreeCtx;
+        /**
+         * Callback which will free the URB once it's reaped and completed.
+         * @param   pUrb    The URB.
+         */
+        DECLCALLBACKMEMBER(void, pfnFree)(PVUSBURB pUrb);
         /** Submit timestamp. (logging only) */
         uint64_t        u64SubmitTS;
@@ -162 +960 @@
     {
         /** The endpoint descriptor address. */
-        uint32_t        EdAddr;
+        RTGCPHYS32      EdAddr;
         /** Number of Tds in the array. */
         uint32_t        cTds;
@@ -168 +966 @@
         struct VUSBURBHCITD
         {
+            /** Type of TD (private) */
+            uint32_t        TdType;
             /** The address of the */
-            uint32_t        TdAddr;
+            RTGCPHYS32      TdAddr;
             /** A copy of the TD. */
-            uint32_t        TdCopy[4];
+            uint32_t        TdCopy[16];
         }              *paTds;
         /** URB chain pointer. */
         PVUSBURB        pNext;
-        /** When this URB was created. (logging only) */
+        /** When this URB was created.
+         * (Used for isochronous frames and for logging.) */
         uint32_t        u32FrameNo;
         /** Flag indicating that the TDs have been unlinked. */
@@ -190 +991 @@
     } Dev;
 
-    /** The device - can be NULL untill submit is attempted.
-     * This is set when allocating the URB. */
-    struct VUSBDEV *pDev;
+#ifndef RDESKTOP
+    /** The USB device instance this belongs to.
+     * This is NULL if the device address is invalid, in which case this belongs to the hub. */
+    PPDMUSBINS      pUsbIns;
+#endif
     /** The device address.
      * This is set at allocation time. */
@@ -198 +1001 @@
 
     /** The endpoint.
-     * IN: Must be set before submitting the URB. */
+     * IN: Must be set before submitting the URB.
+     * @remark This does not have the high bit (direction) set! */
     uint8_t         EndPt;
     /** The transfer type.
@@ -212 +1016 @@
      * OUT: This is set when reaping the URB. */
     VUSBSTATUS      enmStatus;
+
+    /** The number of isochronous packets describe in aIsocPkts.
+     * This is ignored when enmType isn't VUSBXFERTYPE_ISOC. */
+    uint32_t        cIsocPkts;
+    /** The iso packets within abData.
+     * This is ignored when enmType isn't VUSBXFERTYPE_ISOC. */
+    VUSBURBISOCPKT  aIsocPkts[8];
+
     /** The message length.
      * IN: The amount of data to send / receive - set at allocation time.
@@ -223 +1035 @@
 
 /** The magic value of a valid VUSBURB. (Murakami Haruki) */
-#define VUSBURB_MAGIC   0x19490112
+#define VUSBURB_MAGIC       UINT32_C(0x19490112)
 
 /** @} */
+
+
+/** @} */
+
+RT_C_DECLS_END
+
+#endif