VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetStringDescriptor(PDEVICE_OBJECT pDevObj, char *pszResult, ULONG cbResult,
int iIndex, int LangId, ULONG dwTimeoutMs)
{
char aBuf[MAXIMUM_USB_STRING_LENGTH];
AssertCompile(sizeof (aBuf) <= UINT8_MAX);
UCHAR cbBuf = (UCHAR)sizeof (aBuf);
PUSB_STRING_DESCRIPTOR pDr = (PUSB_STRING_DESCRIPTOR)&aBuf;
Assert(pszResult);
*pszResult = 0;
memset(pDr, 0, cbBuf);
pDr->bLength = cbBuf;
pDr->bDescriptorType = USB_STRING_DESCRIPTOR_TYPE;
NTSTATUS Status = VBoxUsbToolGetDescriptor(pDevObj, pDr, cbBuf, USB_STRING_DESCRIPTOR_TYPE, iIndex, LangId, dwTimeoutMs);
if (NT_SUCCESS(Status))
{
if (pDr->bLength >= sizeof (USB_STRING_DESCRIPTOR))
{
int rc = RTUtf16ToUtf8Ex(pDr->bString, (pDr->bLength - RT_OFFSETOF(USB_STRING_DESCRIPTOR, bString)) / sizeof(RTUTF16),
&pszResult, cbResult, NULL /*pcch*/);
if (RT_SUCCESS(rc))
{
USBLibPurgeEncoding(pszResult);
Status = STATUS_SUCCESS;
}
else
Status = STATUS_UNSUCCESSFUL;
}
else
Status = STATUS_INVALID_PARAMETER;
}
return Status;
}
static int solarisWalkDeviceNode(di_node_t Node, void *pvArg)
{
PUSBDEVICELIST pList = (PUSBDEVICELIST)pvArg;
AssertPtrReturn(pList, DI_WALK_TERMINATE);
/*
* Check if it's a USB device in the first place.
*/
bool fUSBDevice = false;
char *pszCompatNames = NULL;
int cCompatNames = di_compatible_names(Node, &pszCompatNames);
for (int i = 0; i < cCompatNames; i++, pszCompatNames += strlen(pszCompatNames) + 1)
if (!strncmp(pszCompatNames, RT_STR_TUPLE("usb")))
{
fUSBDevice = true;
break;
}
if (!fUSBDevice)
return DI_WALK_CONTINUE;
/*
* Check if it's a device node or interface.
*/
int *pInt = NULL;
char *pStr = NULL;
int rc = DI_WALK_CONTINUE;
if (di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "interface", &pInt) < 0)
{
/* It's a device node. */
char *pszDevicePath = di_devfs_path(Node);
PUSBDEVICE pCur = (PUSBDEVICE)RTMemAllocZ(sizeof(*pCur));
if (!pCur)
{
LogRel(("USBService: failed to allocate %d bytes for PUSBDEVICE.\n", sizeof(*pCur)));
return DI_WALK_TERMINATE;
}
bool fValidDevice = false;
do
{
AssertBreak(pszDevicePath);
char *pszDriverName = di_driver_name(Node);
/*
* Skip hubs
*/
if ( pszDriverName
&& !strcmp(pszDriverName, "hubd"))
{
break;
}
/*
* Mandatory.
* snv_85 and above have usb-dev-descriptor node properties, but older one's do not.
* So if we cannot obtain the entire device descriptor, we try falling back to the
* individual properties (those must not fail, if it does we drop the device).
*/
uchar_t *pDevData = NULL;
int cbProp = di_prop_lookup_bytes(DDI_DEV_T_ANY, Node, "usb-dev-descriptor", &pDevData);
if ( cbProp > 0
&& pDevData)
{
usb_dev_descr_t *pDeviceDescriptor = (usb_dev_descr_t *)pDevData;
pCur->bDeviceClass = pDeviceDescriptor->bDeviceClass;
pCur->bDeviceSubClass = pDeviceDescriptor->bDeviceSubClass;
pCur->bDeviceProtocol = pDeviceDescriptor->bDeviceProtocol;
pCur->idVendor = pDeviceDescriptor->idVendor;
pCur->idProduct = pDeviceDescriptor->idProduct;
pCur->bcdDevice = pDeviceDescriptor->bcdDevice;
pCur->bcdUSB = pDeviceDescriptor->bcdUSB;
pCur->bNumConfigurations = pDeviceDescriptor->bNumConfigurations;
pCur->fPartialDescriptor = false;
}
else
{
AssertBreak(di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "usb-vendor-id", &pInt) > 0);
pCur->idVendor = (uint16_t)*pInt;
AssertBreak(di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "usb-product-id", &pInt) > 0);
pCur->idProduct = (uint16_t)*pInt;
AssertBreak(di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "usb-revision-id", &pInt) > 0);
pCur->bcdDevice = (uint16_t)*pInt;
AssertBreak(di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "usb-release", &pInt) > 0);
pCur->bcdUSB = (uint16_t)*pInt;
pCur->fPartialDescriptor = true;
}
char *pszPortAddr = di_bus_addr(Node);
if (pszPortAddr)
pCur->bPort = RTStrToUInt8(pszPortAddr); /* Bus & Port are mixed up (kernel driver/userland) */
else
pCur->bPort = 0;
char szBuf[PATH_MAX + 48];
RTStrPrintf(szBuf, sizeof(szBuf), "%#x:%#x:%d:%s", pCur->idVendor, pCur->idProduct, pCur->bcdDevice, pszDevicePath);
pCur->pszAddress = RTStrDup(szBuf);
AssertBreak(pCur->pszAddress);
pCur->pszDevicePath = RTStrDup(pszDevicePath);
AssertBreak(pCur->pszDevicePath);
pCur->pszBackend = RTStrDup("host");
AssertBreak(pCur->pszBackend);
/*
* Optional (some devices don't have all these)
*/
char *pszCopy;
if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "usb-product-name", &pStr) > 0)
{
pCur->pszProduct = pszCopy = RTStrDup(pStr);
USBLibPurgeEncoding(pszCopy);
}
if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "usb-vendor-name", &pStr) > 0)
{
pCur->pszManufacturer = pszCopy = RTStrDup(pStr);
USBLibPurgeEncoding(pszCopy);
}
if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "usb-serialno", &pStr) > 0)
{
pCur->pszSerialNumber = pszCopy = RTStrDup(pStr);
USBLibPurgeEncoding(pszCopy);
}
if (pCur->bcdUSB == 0x300)
pCur->enmSpeed = USBDEVICESPEED_SUPER;
else if (di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "low-speed", &pInt) >= 0)
pCur->enmSpeed = USBDEVICESPEED_LOW;
else if (di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "high-speed", &pInt) >= 0)
pCur->enmSpeed = USBDEVICESPEED_HIGH;
else
pCur->enmSpeed = USBDEVICESPEED_FULL;
/* Determine state of the USB device. */
pCur->enmState = solarisDetermineUSBDeviceState(pCur, Node);
/*
* Valid device, add it to the list.
*/
fValidDevice = true;
pCur->pPrev = pList->pTail;
if (pList->pTail)
pList->pTail = pList->pTail->pNext = pCur;
else
pList->pTail = pList->pHead = pCur;
rc = DI_WALK_CONTINUE;
} while (0);
di_devfs_path_free(pszDevicePath);
if (!fValidDevice)
solarisFreeUSBDevice(pCur);
}
return rc;
}
