USBProxyServiceLinux.cpp revision bb0bf5f0d07a55839823656d524b6af71abac5c7
/** @file
*
* VBox frontends: Basic Frontend (BFE):
* Implementation of USBProxyServiceLinux class
*/
/*
* Copyright (C) 2006 InnoTek Systemberatung GmbH
*
* 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 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.
*
* If you received this file as part of a commercial VirtualBox
* distribution, then only the terms of your commercial VirtualBox
* license agreement apply instead of the previous paragraph.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#include "USBProxyService.h"
#include "Logging.h"
#include <VBox/usb.h>
#include <VBox/err.h>
#include <iprt/string.h>
#include <iprt/alloc.h>
#include <iprt/assert.h>
#include <iprt/file.h>
#include <iprt/err.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <sys/statfs.h>
#include <sys/poll.h>
#include <unistd.h>
#ifndef NO_COMPILER_H
# include <linux/compiler.h>
#endif
#include <linux/usbdevice_fs.h>
/*******************************************************************************
* Structures and Typedefs *
*******************************************************************************/
/** Suffix translation. */
typedef struct USBSUFF
{
char szSuff[4];
unsigned cchSuff;
unsigned uMul;
unsigned uDiv;
} USBSUFF, *PUSBSUFF;
typedef const USBSUFF *PCUSBSUFF;
/*******************************************************************************
* Global Variables *
*******************************************************************************/
/**
* Suffixes for the endpoint polling interval.
*/
static const USBSUFF s_aIntervalSuff[] =
{
{ "ms", 2, 1, 0 },
{ "us", 2, 1, 1000 },
{ "ns", 2, 1, 1000000 },
{ "s", 1, 1000, 0 },
{ "", 0, 0, 0 } /* term */
};
/**
* Initialize data members.
*/
USBProxyServiceLinux::USBProxyServiceLinux (HostUSB *aHost, const char *aUsbfsRoot /* = "/proc/bus/usb" */)
: USBProxyService (aHost), mFile (NIL_RTFILE), mStream (NULL), mWakeupPipeR (NIL_RTFILE),
mWakeupPipeW (NIL_RTFILE), mUsbfsRoot (aUsbfsRoot)
{
LogFlowMember (("USBProxyServiceLinux::USBProxyServiceLinux: aHost=%p aUsbfsRoot=%p:{%s}\n", aHost, aUsbfsRoot, aUsbfsRoot));
/*
* Open the devices file.
*/
int rc = VERR_NO_MEMORY;
char *pszDevices;
RTStrAPrintf (&pszDevices, "%s/devices", aUsbfsRoot);
if (pszDevices)
{
rc = RTFileOpen (&mFile, pszDevices, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
if (VBOX_SUCCESS (rc))
{
/*
* Check that we're actually on the usbfs.
*/
struct statfs StFS;
if (!fstatfs (mFile, &StFS))
{
if (StFS.f_type == USBDEVICE_SUPER_MAGIC)
{
int pipes[2];
if (!pipe (pipes))
{
mWakeupPipeR = pipes[0];
mWakeupPipeW = pipes[1];
mStream = fdopen (mFile, "r");
if (mStream)
{
/*
* Start the poller thread.
*/
rc = start();
if (VBOX_SUCCESS (rc))
{
RTStrFree (pszDevices);
LogFlowMember (("USBProxyServiceLinux::USBProxyServiceLinux: returns successfully - mFile=%d mStream=%p mWakeupPipeR/W=%d/%d\n",
mFile, mStream, mWakeupPipeR, mWakeupPipeW));
return;
}
fclose (mStream);
mStream = NULL;
mFile = NIL_RTFILE;
}
RTFileClose (mWakeupPipeR);
RTFileClose (mWakeupPipeW);
mWakeupPipeW = mWakeupPipeR = NIL_RTFILE;
}
}
else
{
Log (("USBProxyServiceLinux::USBProxyServiceLinux: StFS.f_type=%d expected=%d\n", StFS.f_type, USBDEVICE_SUPER_MAGIC));
rc = VERR_INVALID_PARAMETER;
}
}
else
{
rc = RTErrConvertFromErrno (errno);
Log (("USBProxyServiceLinux::USBProxyServiceLinux: fstatfs failed, errno=%d\n", errno));
}
RTFileClose (mFile);
mFile = NIL_RTFILE;
}
else
{
#ifndef DEBUG_fm3
/* I'm currently using Linux with disabled USB support */
AssertRC (rc);
#endif
Log (("USBProxyServiceLinux::USBProxyServiceLinux: RTFileOpen(,%s,,) -> %Vrc\n", pszDevices, rc));
}
RTStrFree (pszDevices);
}
else
Log (("USBProxyServiceLinux::USBProxyServiceLinux: out of memory!\n"));
mLastError = rc;
LogFlowMember (("USBProxyServiceLinux::USBProxyServiceLinux: returns failure!!! (rc=%Vrc)\n", rc));
}
/**
* Stop all service threads and free the device chain.
*/
USBProxyServiceLinux::~USBProxyServiceLinux()
{
LogFlowMember (("USBProxyServiceLinux::~USBProxyServiceLinux:\n"));
/*
* Stop the service.
*/
if (isActive())
stop();
/*
* Free resources.
*/
if (mStream)
{
fclose (mStream);
mStream = NULL;
mFile = NIL_RTFILE;
}
else if (mFile != NIL_RTFILE)
{
RTFileClose (mFile);
mFile = NIL_RTFILE;
}
RTFileClose (mWakeupPipeR);
RTFileClose (mWakeupPipeW);
mWakeupPipeW = mWakeupPipeR = NIL_RTFILE;
}
int USBProxyServiceLinux::captureDevice (HostUSBDevice *aDevice)
{
/*
* Don't think we need to do anything when the device is held...
*/
return VINF_SUCCESS;
}
int USBProxyServiceLinux::holdDevice (HostUSBDevice *pDevice)
{
/*
* This isn't really implemented, we can usually wrestle
* any user when we need it... Anyway, I don't have anywhere to store
* any info per device atm.
*/
return VINF_SUCCESS;
}
int USBProxyServiceLinux::releaseDevice (HostUSBDevice *aDevice)
{
/*
* We're not really holding it atm.
*/
return VINF_SUCCESS;
}
int USBProxyServiceLinux::resetDevice (HostUSBDevice *aDevice)
{
/*
* We don't dare reset anything, but the USB Proxy Device
* will reset upon detach, so this should be ok.
*/
return VINF_SUCCESS;
}
int USBProxyServiceLinux::wait (unsigned aMillies)
{
struct pollfd PollFds[2];
memset(&PollFds, 0, sizeof(PollFds));
PollFds[0].fd = mFile;
PollFds[0].events = POLLIN;
PollFds[1].fd = mWakeupPipeR;
PollFds[1].events = POLLIN | POLLERR | POLLHUP;
int rc = poll (&PollFds[0], 2, aMillies);
if (rc == 0)
return VERR_TIMEOUT;
if (rc > 0)
return VINF_SUCCESS;
return RTErrConvertFromErrno (errno);
}
int USBProxyServiceLinux::interruptWait (void)
{
int rc = RTFileWrite (mWakeupPipeW, "Wakeup!", sizeof("Wakeup!") - 1, NULL);
if (VBOX_SUCCESS (rc))
fsync (mWakeupPipeW);
return rc;
}
/**
* "reads" the number suffix. It's more like validating it and
* skipping the necessary number of chars.
*/
static int usbReadSkipSuffix (char **ppszNext)
{
char *pszNext = *ppszNext;
if (!isspace (*pszNext) && *pszNext)
{
/* skip unit */
if (pszNext[0] == 'm' && pszNext[1] == 's')
pszNext += 2;
else if (pszNext[0] == 'm' && pszNext[1] == 'A')
pszNext += 2;
/* skip parenthesis */
if (*pszNext == '(')
{
pszNext = strchr (pszNext, ')');
if (!pszNext++)
{
AssertMsgFailed (("*ppszNext=%s\n", *ppszNext));
return VERR_PARSE_ERROR;
}
}
/* blank or end of the line. */
if (!isspace (*pszNext) && *pszNext)
{
AssertMsgFailed (("pszNext=%s\n", pszNext));
return VERR_PARSE_ERROR;
}
/* it's ok. */
*ppszNext = pszNext;
}
return VINF_SUCCESS;
}
/**
* Reads a USB number returning the number and the position of the next character to parse.
*/
static int usbReadNum (const char *pszValue, unsigned uBase, uint32_t u32Mask, PCUSBSUFF paSuffs, void *pvNum, char **ppszNext)
{
/*
* Initialize return value to zero and strip leading spaces.
*/
switch (u32Mask)
{
case 0xff: *(uint8_t *)pvNum = 0; break;
case 0xffff: *(uint16_t *)pvNum = 0; break;
case 0xffffffff: *(uint32_t *)pvNum = 0; break;
}
pszValue = RTStrStripL (pszValue);
if (*pszValue)
{
/*
* Try convert the number.
*/
char *pszNext;
uint32_t u32 = 0;
RTStrToUInt32Ex (pszValue, &pszNext, uBase, &u32);
if (pszNext == pszValue)
{
AssertMsgFailed (("pszValue=%d\n", pszValue));
return VERR_NO_DATA;
}
/*
* Check the range.
*/
if (u32 & ~u32Mask)
{
AssertMsgFailed (("pszValue=%d u32=%#x lMask=%#x\n", pszValue, u32, u32Mask));
return VERR_OUT_OF_RANGE;
}
/*
* Validate and skip stuff following the number.
*/
if (paSuffs)
{
if (!isspace (*pszNext) && *pszNext)
{
for (PCUSBSUFF pSuff = paSuffs; pSuff->szSuff[0]; pSuff++)
{
if ( !strncmp (pSuff->szSuff, pszNext, pSuff->cchSuff)
&& (!pszNext[pSuff->cchSuff] || isspace (pszNext[pSuff->cchSuff])))
{
if (pSuff->uDiv)
u32 /= pSuff->uDiv;
else
u32 *= pSuff->uMul;
break;
}
}
}
}
else
{
int rc = usbReadSkipSuffix (&pszNext);
if (VBOX_FAILURE (rc))
return rc;
}
*ppszNext = pszNext;
/*
* Set the value.
*/
switch (u32Mask)
{
case 0xff: *(uint8_t *)pvNum = (uint8_t)u32; break;
case 0xffff: *(uint16_t *)pvNum = (uint16_t)u32; break;
case 0xffffffff: *(uint32_t *)pvNum = (uint32_t)u32; break;
}
}
return VINF_SUCCESS;
}
static int usbRead8 (const char *pszValue, unsigned uBase, uint8_t *pu8, char **ppszNext)
{
return usbReadNum (pszValue, uBase, 0xff, NULL, pu8, ppszNext);
}
static int usbRead16 (const char *pszValue, unsigned uBase, uint16_t *pu16, char **ppszNext)
{
return usbReadNum (pszValue, uBase, 0xffff, NULL, pu16, ppszNext);
}
static int usbRead16Suff (const char *pszValue, unsigned uBase, PCUSBSUFF paSuffs, uint16_t *pu16, char **ppszNext)
{
return usbReadNum (pszValue, uBase, 0xffff, paSuffs, pu16, ppszNext);
}
/**
* Reads a USB BCD number returning the number and the position of the next character to parse.
* The returned number contains the integer part in the high byte and the decimal part in the low byte.
*/
static int usbReadBCD (const char *pszValue, unsigned uBase, uint16_t *pu16, char **ppszNext)
{
/*
* Initialize return value to zero and strip leading spaces.
*/
*pu16 = 0;
pszValue = RTStrStripL (pszValue);
if (*pszValue)
{
/*
* Try convert the number.
*/
/* integer part */
char *pszNext;
uint32_t u32Int = 0;
RTStrToUInt32Ex (pszValue, &pszNext, uBase, &u32Int);
if (pszNext == pszValue)
{
AssertMsgFailed (("pszValue=%s\n", pszValue));
return VERR_NO_DATA;
}
if (u32Int & ~0xff)
{
AssertMsgFailed (("pszValue=%s u32Int=%#x (int)\n", pszValue, u32Int));
return VERR_OUT_OF_RANGE;
}
/* skip dot and read decimal part */
if (*pszNext != '.')
{
AssertMsgFailed (("pszValue=%s pszNext=%s (int)\n", pszValue, pszNext));
return VERR_PARSE_ERROR;
}
char *pszValue2 = RTStrStripL (pszNext + 1);
uint32_t u32Dec = 0;
RTStrToUInt32Ex (pszValue2, &pszNext, uBase, &u32Dec);
if (pszNext == pszValue)
{
AssertMsgFailed (("pszValue=%s\n", pszValue));
return VERR_NO_DATA;
}
if (u32Dec & ~0xff)
{
AssertMsgFailed (("pszValue=%s u32Dec=%#x\n", pszValue, u32Dec));
return VERR_OUT_OF_RANGE;
}
/*
* Validate and skip stuff following the number.
*/
int rc = usbReadSkipSuffix (&pszNext);
if (VBOX_FAILURE (rc))
return rc;
*ppszNext = pszNext;
/*
* Set the value.
*/
*pu16 = (uint16_t)u32Int << 8 | (uint16_t)u32Dec;
}
return VINF_SUCCESS;
}
/**
* Reads a string, i.e. allocates memory and copies it.
*
* We assume that a string is pure ASCII, if that's not the case
* tell me how to figure out the codeset please.
*/
static int usbReadStr (const char *pszValue, const char **ppsz)
{
if (*ppsz)
RTStrFree ((char *)*ppsz);
*ppsz = RTStrDup (pszValue);
if (*ppsz)
return VINF_SUCCESS;
return VERR_NO_MEMORY;
}
/**
* Skips the current property.
*/
static char * usbReadSkip (const char *pszValue)
{
char *psz = strchr (pszValue, '=');
if (psz)
psz = strchr (psz + 1, '=');
if (!psz)
return strchr (pszValue, '\0');
while (psz > pszValue && !isspace (psz[-1]))
psz--;
Assert (psz > pszValue);
return psz;
}
/**
* Compare a prefix and returns pointer to the char following it if it matches.
*/
static char *usbPrefix (char *psz, const char *pszPref, size_t cchPref)
{
if (strncmp (psz, pszPref, cchPref))
return NULL;
return psz + cchPref;
}
/**
* Checks which state the device is in.
*/
static USBDEVICESTATE usbDeterminState (PCUSBDEVICE pDevice)
{
if (!pDevice->idVendor)
return USBDEVICESTATE_UNSUPPORTED;
/*
* We cannot distinguish between USED_BY_HOST_CAPTURABLE and
* USED_BY_GUEST, HELD_BY_PROXY all that well and it shouldn't be
* necessary either.
*/
USBDEVICESTATE enmState = USBDEVICESTATE_UNUSED;
for (int iCfg = pDevice->bNumConfigurations - 1; iCfg >= 0; iCfg--)
for (int iIf = pDevice->paConfigurations[iCfg].bConfigurationValue - 1; iIf >= 0; iIf--)
{
const char *pszDriver = pDevice->paConfigurations[iCfg].paInterfaces[iIf].pszDriver;
if (pszDriver)
{
if (!strcmp (pszDriver, "hub"))
{
enmState = USBDEVICESTATE_USED_BY_HOST;
break;
}
enmState = USBDEVICESTATE_USED_BY_HOST_CAPTURABLE;
}
}
return enmState;
}
PUSBDEVICE USBProxyServiceLinux::getDevices (void)
{
PUSBDEVICE pFirst = NULL;
if (mStream)
{
PUSBDEVICE *ppNext = NULL;
USBDEVICE Dev = {0};
int cHits = 0;
int iCfg = 0;
PUSBCONFIG pCfg = NULL;
PUSBINTERFACE pIf = NULL;
int iEp = 0;
PUSBENDPOINT pEp = NULL;
char szLine[1024];
rewind (mStream);
int rc = VINF_SUCCESS;
while ( VBOX_SUCCESS (rc)
&& fgets (szLine, sizeof (szLine), mStream))
{
char *psz;
char *pszValue;
/* validate and remove the trailing newline. */
psz = strchr (szLine, '\0');
if (psz[-1] != '\n' && !feof (mStream))
{
AssertMsgFailed (("Line too long. (cch=%d)\n", strlen (szLine)));
continue;
}
/* strip */
psz = RTStrStrip (szLine);
if (!*psz)
continue;
/*
* Interpret the line.
* (Ordered by normal occurence.)
*/
char ch = psz[0];
if (psz[1] != ':')
continue;
psz = RTStrStripL (psz + 3);
#define PREFIX(str) ( (pszValue = usbPrefix (psz, str, sizeof (str) - 1)) != NULL )
switch (ch)
{
/*
* T: Bus=dd Lev=dd Prnt=dd Port=dd Cnt=dd Dev#=ddd Spd=ddd MxCh=dd
* | | | | | | | | |__MaxChildren
* | | | | | | | |__Device Speed in Mbps
* | | | | | | |__DeviceNumber
* | | | | | |__Count of devices at this level
* | | | | |__Connector/Port on Parent for this device
* | | | |__Parent DeviceNumber
* | | |__Level in topology for this bus
* | |__Bus number
* |__Topology info tag
*/
case 'T':
/* add */
AssertMsg (cHits >= 3 || cHits == 0, ("cHits=%d\n", cHits));
if (cHits >= 3)
{
Dev.enmState = usbDeterminState (&Dev);
PUSBDEVICE pDev = (PUSBDEVICE) RTMemAlloc (sizeof(*pDev));
if (pDev)
{
*pDev = Dev;
if (Dev.enmState != USBDEVICESTATE_UNSUPPORTED)
{
RTStrAPrintf((char **)&pDev->pszAddress, "%s/%03d/%03d", mUsbfsRoot.c_str(), pDev->bBus, pDev->bDevNum);
if (pDev->pszAddress)
{
if (ppNext)
*ppNext = pDev;
else
pFirst = pDev;
ppNext = &pDev->pNext;
}
else
{
freeDevice (pDev);
rc = VERR_NO_MEMORY;
}
}
else
freeDevice (pDev);
memset (&Dev, 0, sizeof (Dev));
}
else
rc = VERR_NO_MEMORY;
}
/* Reset device state */
cHits = 1;
iCfg = 0;
pCfg = NULL;
pIf = NULL;
iEp = 0;
pEp = NULL;
/* parse the line. */
while (*psz && VBOX_SUCCESS (rc))
{
if (PREFIX ("Bus="))
rc = usbRead8 (pszValue, 10, &Dev.bBus, &psz);
else if (PREFIX ("Lev="))
rc = usbRead8 (pszValue, 10, &Dev.bLevel, &psz);
else if (PREFIX ("Dev#="))
rc = usbRead8 (pszValue, 10, &Dev.bDevNum, &psz);
else if (PREFIX ("Prnt="))
rc = usbRead8 (pszValue, 10, &Dev.bDevNumParent, &psz);
else if (PREFIX ("Port="))
rc = usbRead8 (pszValue, 10, &Dev.bPort, &psz);
else if (PREFIX ("Cnt="))
rc = usbRead8 (pszValue, 10, &Dev.bNumDevices, &psz);
//else if (PREFIX ("Spd="))
// rc = usbReadSpeed (pszValue, &Dev.cbSpeed, &psz);
else if (PREFIX ("MxCh="))
rc = usbRead8 (pszValue, 10, &Dev.bMaxChildren, &psz);
else
psz = usbReadSkip (psz);
psz = RTStrStripL (psz);
}
break;
/*
* Bandwidth info:
* B: Alloc=ddd/ddd us (xx%), #Int=ddd, #Iso=ddd
* | | | |__Number of isochronous requests
* | | |__Number of interrupt requests
* | |__Total Bandwidth allocated to this bus
* |__Bandwidth info tag
*/
case 'B':
break;
/*
* D: Ver=x.xx Cls=xx(sssss) Sub=xx Prot=xx MxPS=dd #Cfgs=dd
* | | | | | | |__NumberConfigurations
* | | | | | |__MaxPacketSize of Default Endpoint
* | | | | |__DeviceProtocol
* | | | |__DeviceSubClass
* | | |__DeviceClass
* | |__Device USB version
* |__Device info tag #1
*/
case 'D':
while (*psz && VBOX_SUCCESS (rc))
{
if (PREFIX ("Ver="))
rc = usbReadBCD (pszValue, 16, &Dev.bcdUSB, &psz);
else if (PREFIX ("Cls="))
rc = usbRead8 (pszValue, 16, &Dev.bDeviceClass, &psz);
else if (PREFIX ("Sub="))
rc = usbRead8 (pszValue, 16, &Dev.bDeviceSubClass, &psz);
else if (PREFIX ("Prot="))
rc = usbRead8 (pszValue, 16, &Dev.bDeviceProtocol, &psz);
//else if (PREFIX ("MxPS="))
// rc = usbRead16 (pszValue, 10, &Dev.wMaxPacketSize, &psz);
else if (PREFIX ("#Cfgs="))
rc = usbRead8 (pszValue, 10, &Dev.bNumConfigurations, &psz);
else
psz = usbReadSkip (psz);
psz = RTStrStripL (psz);
}
cHits++;
break;
/*
* P: Vendor=xxxx ProdID=xxxx Rev=xx.xx
* | | | |__Product revision number
* | | |__Product ID code
* | |__Vendor ID code
* |__Device info tag #2
*/
case 'P':
while (*psz && VBOX_SUCCESS (rc))
{
if (PREFIX ("Vendor="))
rc = usbRead16 (pszValue, 16, &Dev.idVendor, &psz);
else if (PREFIX ("ProdID="))
rc = usbRead16 (pszValue, 16, &Dev.idProduct, &psz);
else if (PREFIX ("Rev="))
rc = usbReadBCD (pszValue, 16, &Dev.bcdDevice, &psz);
else
psz = usbReadSkip (psz);
psz = RTStrStripL (psz);
}
cHits++;
break;
/*
* String.
*/
case 'S':
if (PREFIX ("Manufacturer="))
rc = usbReadStr (pszValue, &Dev.pszManufacturer);
else if (PREFIX ("Product="))
rc = usbReadStr (pszValue, &Dev.pszProduct);
else if (PREFIX ("SerialNumber="))
{
rc = usbReadStr (pszValue, &Dev.pszSerialNumber);
if (VBOX_SUCCESS (rc))
Dev.u64SerialHash = calcSerialHash (pszValue);
}
break;
/*
* C:* #Ifs=dd Cfg#=dd Atr=xx MPwr=dddmA
* | | | | | |__MaxPower in mA
* | | | | |__Attributes
* | | | |__ConfiguratioNumber
* | | |__NumberOfInterfaces
* | |__ "*" indicates the active configuration (others are " ")
* |__Config info tag
*/
case 'C':
{
USBCONFIG Cfg = {0};
Cfg.fActive = psz[-2] == '*';
while (*psz && VBOX_SUCCESS (rc))
{
if (PREFIX ("#Ifs="))
rc = usbRead8 (pszValue, 10, &Cfg.bNumInterfaces, &psz);
else if (PREFIX ("Cfg#="))
rc = usbRead8 (pszValue, 10, &Cfg.bConfigurationValue, &psz);
else if (PREFIX ("Atr="))
rc = usbRead8 (pszValue, 16, &Cfg.bmAttributes, &psz);
else if (PREFIX ("MxPwr="))
rc = usbRead16 (pszValue, 10, &Cfg.u16MaxPower, &psz);
else
psz = usbReadSkip (psz);
psz = RTStrStripL (psz);
}
if (VBOX_SUCCESS (rc))
{
if (iCfg < Dev.bNumConfigurations)
{
/* Add the config. */
if (!Dev.paConfigurations)
{
Dev.paConfigurations = pCfg = (PUSBCONFIG) RTMemAllocZ (sizeof (Cfg) * Dev.bNumConfigurations);
if (pCfg)
{
*pCfg = Cfg;
iCfg = 1;
}
else
rc = VERR_NO_MEMORY;
}
else
{
*++pCfg = Cfg;
iCfg++;
}
}
else
{
AssertMsgFailed (("iCfg=%d bNumConfigurations=%d\n", iCfg, Dev.bNumConfigurations));
rc = VERR_INTERNAL_ERROR;
}
}
/* new config, so, start anew with interfaces and endpoints. */
pIf = NULL;
iEp = 0;
pEp = NULL;
break;
}
/*
* I: If#=dd Alt=dd #EPs=dd Cls=xx(sssss) Sub=xx Prot=xx Driver=ssss
* | | | | | | | |__Driver name
* | | | | | | | or "(none)"
* | | | | | | |__InterfaceProtocol
* | | | | | |__InterfaceSubClass
* | | | | |__InterfaceClass
* | | | |__NumberOfEndpoints
* | | |__AlternateSettingNumber
* | |__InterfaceNumber
* |__Interface info tag
*/
case 'I':
{
USBINTERFACE If = {0};
while (*psz && VBOX_SUCCESS (rc))
{
if (PREFIX ("If#="))
rc = usbRead8 (pszValue, 10, &If.bInterfaceNumber, &psz);
else if (PREFIX ("Alt="))
rc = usbRead8 (pszValue, 10, &If.bAlternateSetting, &psz);
else if (PREFIX ("#EPs="))
rc = usbRead8 (pszValue, 10, &If.bNumEndpoints, &psz);
else if (PREFIX ("Cls="))
rc = usbRead8 (pszValue, 16, &If.bInterfaceClass, &psz);
else if (PREFIX ("Sub="))
rc = usbRead8 (pszValue, 16, &If.bInterfaceSubClass, &psz);
else if (PREFIX ("Prot="))
rc = usbRead8 (pszValue, 16, &If.bInterfaceProtocol, &psz);
else if (PREFIX ("Driver="))
{
rc = usbReadStr (pszValue, &If.pszDriver);
if ( If.pszDriver
&& ( !strcmp (If.pszDriver, "(none)")
|| !strcmp (If.pszDriver, "(no driver)"))
|| !*If.pszDriver)
{
RTStrFree ((char *)If.pszDriver);
If.pszDriver = NULL;
}
break;
}
else
psz = usbReadSkip (psz);
psz = RTStrStripL (psz);
}
if (VBOX_SUCCESS (rc))
{
if (pCfg && If.bInterfaceNumber < pCfg->bNumInterfaces)
{
/* Add the config. */
if (!pCfg->paInterfaces)
{
pCfg->paInterfaces = pIf = (PUSBINTERFACE) RTMemAllocZ (sizeof (If) * pCfg->bNumInterfaces);
if (pIf)
{
Assert (!If.bInterfaceNumber); Assert (!If.bAlternateSetting);
*pIf = If;
}
else
rc = VERR_NO_MEMORY;
}
else
{
/*
* Alternate settings makes life *difficult*!
* ASSUMES: ORDER ASC bInterfaceNumber, bAlternateSetting
*/
pIf = &pCfg->paInterfaces[If.bInterfaceNumber];
if (!If.bAlternateSetting)
*pIf = If;
else
{
PUSBINTERFACE paAlts = (PUSBINTERFACE) RTMemRealloc (pIf->paAlts, (pIf->cAlts + 1) * sizeof(*pIf));
if (paAlts)
{
pIf->paAlts = paAlts;
pIf = &paAlts[pIf->cAlts++];
*pIf = If;
}
else
rc = VERR_NO_MEMORY;
}
}
}
else
{
AssertMsgFailed (("iCfg=%d bInterfaceNumber=%d bNumInterfaces=%d\n", iCfg, If.bInterfaceNumber, pCfg->bNumInterfaces));
rc = VERR_INTERNAL_ERROR;
}
}
/* start anew with endpoints. */
iEp = 0;
pEp = NULL;
break;
}
/*
* E: Ad=xx(s) Atr=xx(ssss) MxPS=dddd Ivl=dddms
* | | | | |__Interval (max) between transfers
* | | | |__EndpointMaxPacketSize
* | | |__Attributes(EndpointType)
* | |__EndpointAddress(I=In,O=Out)
* |__Endpoint info tag
*/
case 'E':
{
USBENDPOINT Ep = {0};
while (*psz && VBOX_SUCCESS (rc))
{
if (PREFIX ("Ad="))
rc = usbRead8 (pszValue, 16, &Ep.bEndpointAddress, &psz);
else if (PREFIX ("Atr="))
rc = usbRead8 (pszValue, 16, &Ep.bmAttributes, &psz);
else if (PREFIX ("MxPS="))
rc = usbRead16 (pszValue, 10, &Ep.wMaxPacketSize, &psz);
else if (PREFIX ("Ivl="))
rc = usbRead16Suff (pszValue, 10, &s_aIntervalSuff[0], &Ep.u16Interval, &psz);
else
psz = usbReadSkip (psz);
psz = RTStrStripL (psz);
}
if (VBOX_SUCCESS (rc))
{
if (pIf && iEp < pIf->bNumEndpoints)
{
/* Add the config. */
if (!pIf->paEndpoints)
{
pIf->paEndpoints = pEp = (PUSBENDPOINT) RTMemAllocZ (sizeof (Ep) * pIf->bNumEndpoints);
if (pEp)
{
*pEp = Ep;
iEp = 1;
}
else
rc = VERR_NO_MEMORY;
}
else
{
*++pEp = Ep;
iEp++;
}
}
else
{
AssertMsgFailed (("iCfg=%d bInterfaceNumber=%d iEp=%d bNumInterfaces=%d\n", iCfg, pIf->bInterfaceNumber, iEp, pIf->bNumEndpoints));
rc = VERR_INTERNAL_ERROR;
}
}
break;
}
}
#undef PREFIX
} /* parse loop */
/*
* Add the current entry.
*/
AssertMsg (cHits >= 3 || cHits == 0, ("cHits=%d\n", cHits));
if (cHits >= 3)
{
Dev.enmState = usbDeterminState (&Dev);
PUSBDEVICE pDev = (PUSBDEVICE) RTMemAlloc (sizeof(*pDev));
if (pDev)
{
*pDev = Dev;
if (Dev.enmState != USBDEVICESTATE_UNSUPPORTED)
{
RTStrAPrintf((char **)&pDev->pszAddress, "%s/%03d/%03d", mUsbfsRoot.c_str(), pDev->bBus, pDev->bDevNum);
if (pDev->pszAddress)
{
if (ppNext)
*ppNext = pDev;
else
pFirst = pDev;
ppNext = &pDev->pNext;
}
else
{
rc = VERR_NO_MEMORY;
freeDevice (pDev);
}
}
else
freeDevice (pDev);
}
else
rc = VERR_NO_MEMORY;
}
/*
* Success?
*/
if (VBOX_FAILURE (rc))
{
LogFlow (("USBProxyServiceLinux::getDevices: rc=%Vrc\n", rc));
while (pFirst)
{
PUSBDEVICE pFree = pFirst;
pFirst = pFirst->pNext;
freeDevice (pFree);
}
}
}
return pFirst;
}