/** * USBA driver election callback. * * @returns USB_SUCCESS if we want to capture the device, USB_FAILURE otherwise. * @param pDevDesc The parsed device descriptor (does not include subconfigs). * @param pDevStrings Device strings: Manufacturer, Product, Serial Number. * @param pszDevicePath The physical path of the device being attached. * @param Bus The Bus number on which the device is on. * @param Port The Port number on the bus. * @param ppszDrv The name of the driver we wish to capture the device with. * @param pvReserved Reserved for future use. */ int VBoxUSBMonSolarisElectDriver(usb_dev_descr_t *pDevDesc, usb_dev_str_t *pDevStrings, char *pszDevicePath, int Bus, int Port, char **ppszDrv, void *pvReserved) { LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisElectDriver pDevDesc=%p pDevStrings=%p pszDevicePath=%s Bus=%d Port=%d\n", pDevDesc, pDevStrings, pszDevicePath, Bus, Port)); AssertPtrReturn(pDevDesc, USB_FAILURE); AssertPtrReturn(pDevStrings, USB_FAILURE); /* * Create a filter from the device being attached. */ USBFILTER Filter; USBFilterInit(&Filter, USBFILTERTYPE_CAPTURE); USBFilterSetNumExact(&Filter, USBFILTERIDX_VENDOR_ID, pDevDesc->idVendor, true); USBFilterSetNumExact(&Filter, USBFILTERIDX_PRODUCT_ID, pDevDesc->idProduct, true); USBFilterSetNumExact(&Filter, USBFILTERIDX_DEVICE_REV, pDevDesc->bcdDevice, true); USBFilterSetNumExact(&Filter, USBFILTERIDX_DEVICE_CLASS, pDevDesc->bDeviceClass, true); USBFilterSetNumExact(&Filter, USBFILTERIDX_DEVICE_SUB_CLASS, pDevDesc->bDeviceSubClass, true); USBFilterSetNumExact(&Filter, USBFILTERIDX_DEVICE_PROTOCOL, pDevDesc->bDeviceProtocol, true); USBFilterSetNumExact(&Filter, USBFILTERIDX_BUS, 0x0 /* Bus */, true); /* Use 0x0 as userland initFilterFromDevice function in Main: see comment on "SetMustBePresent" below */ USBFilterSetNumExact(&Filter, USBFILTERIDX_PORT, Port, true); USBFilterSetStringExact(&Filter, USBFILTERIDX_MANUFACTURER_STR, pDevStrings->usb_mfg, true); USBFilterSetStringExact(&Filter, USBFILTERIDX_PRODUCT_STR, pDevStrings->usb_product, true); USBFilterSetStringExact(&Filter, USBFILTERIDX_SERIAL_NUMBER_STR, pDevStrings->usb_serialno, true); /* This doesn't work like it should (USBFilterMatch fails on matching field (6) i.e. Bus despite this. Investigate later. */ USBFilterSetMustBePresent(&Filter, USBFILTERIDX_BUS, false /* fMustBePresent */); Log((DEVICE_NAME ":VBoxUSBMonSolarisElectDriver: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n", USBFilterGetNum(&Filter, USBFILTERIDX_VENDOR_ID), USBFilterGetNum(&Filter, USBFILTERIDX_PRODUCT_ID), USBFilterGetNum(&Filter, USBFILTERIDX_DEVICE_REV), USBFilterGetNum(&Filter, USBFILTERIDX_DEVICE_CLASS), USBFilterGetNum(&Filter, USBFILTERIDX_DEVICE_SUB_CLASS), USBFilterGetNum(&Filter, USBFILTERIDX_DEVICE_PROTOCOL), USBFilterGetNum(&Filter, USBFILTERIDX_BUS), USBFilterGetNum(&Filter, USBFILTERIDX_PORT))); Log((DEVICE_NAME ":VBoxUSBMonSolarisElectDriver: Manufacturer=%s Product=%s Serial=%s\n", USBFilterGetString(&Filter, USBFILTERIDX_MANUFACTURER_STR) ? USBFilterGetString(&Filter, USBFILTERIDX_MANUFACTURER_STR) : "<null>", USBFilterGetString(&Filter, USBFILTERIDX_PRODUCT_STR) ? USBFilterGetString(&Filter, USBFILTERIDX_PRODUCT_STR) : "<null>", USBFilterGetString(&Filter, USBFILTERIDX_SERIAL_NUMBER_STR) ? USBFilterGetString(&Filter, USBFILTERIDX_SERIAL_NUMBER_STR) : "<null>")); /* * Run through user filters and try to see if it has a match. */ uintptr_t uId = 0; RTPROCESS Owner = VBoxUSBFilterMatch(&Filter, &uId); USBFilterDelete(&Filter); if (Owner == NIL_RTPROCESS) { Log((DEVICE_NAME ":No matching filters, device %#x:%#x uninteresting.\n", pDevDesc->idVendor, pDevDesc->idProduct)); return USB_FAILURE; } *ppszDrv = ddi_strdup(VBOXUSB_DRIVER_NAME, KM_SLEEP); LogRel((DEVICE_NAME ": Capturing %s %#x:%#x:%s\n", pDevStrings->usb_product ? pDevStrings->usb_product : "<Unnamed USB device>", pDevDesc->idVendor, pDevDesc->idProduct, pszDevicePath)); return USB_SUCCESS; }
/** * Converts a USBFilter field into a string. * * (This function is also used by HostUSBDeviceFilter.) * * @param aFilter The filter. * @param aIdx The field index. * @param aStr The output string. */ static void i_usbFilterFieldToString(PCUSBFILTER aFilter, USBFILTERIDX aIdx, Utf8Str &rstrOut) { const USBFILTERMATCH matchingMethod = USBFilterGetMatchingMethod(aFilter, aIdx); Assert(matchingMethod != USBFILTERMATCH_INVALID); if (USBFilterIsMethodNumeric(matchingMethod)) { int value = USBFilterGetNum(aFilter, aIdx); Assert(value >= 0 && value <= 0xffff); rstrOut = Utf8StrFmt("%04RX16", (uint16_t)value); } else if (USBFilterIsMethodString(matchingMethod)) rstrOut = USBFilterGetString(aFilter, aIdx); else rstrOut.setNull(); }
/** * IOCtl processor for user to kernel and kernel to kernel communication. * * @returns VBox status code. * * @param iFunction The requested function. * @param pvState Opaque pointer to driver state used for getting ring-3 process (Id). * @param pvData The input/output data buffer. Can be NULL depending on the function. * @param cbData The max size of the data buffer. * @param pcbDataReturned Where to store the amount of returned data. Can be NULL. */ static int vboxUSBMonSolarisProcessIOCtl(int iFunction, void *pvState, void *pvData, size_t cbData, size_t *pcbReturnedData) { LogFunc((DEVICE_NAME ":solarisUSBProcessIOCtl iFunction=%d pvBuf=%p cbBuf=%zu\n", iFunction, pvData, cbData)); AssertPtrReturn(pvState, VERR_INVALID_POINTER); vboxusbmon_state_t *pState = (vboxusbmon_state_t *)pvState; int rc; #define CHECKRET_MIN_SIZE(mnemonic, cbMin) \ do { \ if (cbData < (cbMin)) \ { \ LogRel(("vboxUSBSolarisProcessIOCtl: " mnemonic ": cbData=%#zx (%zu) min is %#zx (%zu)\n", \ cbData, cbData, (size_t)(cbMin), (size_t)(cbMin))); \ return VERR_BUFFER_OVERFLOW; \ } \ if ((cbMin) != 0 && !VALID_PTR(pvData)) \ { \ LogRel(("vboxUSBSolarisProcessIOCtl: " mnemonic ": Invalid pointer %p\n", pvData)); \ return VERR_INVALID_POINTER; \ } \ } while (0) switch (iFunction) { case VBOXUSBMON_IOCTL_ADD_FILTER: { CHECKRET_MIN_SIZE("ADD_FILTER", sizeof(VBOXUSBREQ_ADD_FILTER)); VBOXUSBREQ_ADD_FILTER *pReq = (VBOXUSBREQ_ADD_FILTER *)pvData; PUSBFILTER pFilter = (PUSBFILTER)&pReq->Filter; Log(("vboxUSBMonSolarisProcessIOCtl: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n", USBFilterGetNum(pFilter, USBFILTERIDX_VENDOR_ID), USBFilterGetNum(pFilter, USBFILTERIDX_PRODUCT_ID), USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_REV), USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_CLASS), USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_SUB_CLASS), USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_PROTOCOL), USBFilterGetNum(pFilter, USBFILTERIDX_BUS), USBFilterGetNum(pFilter, USBFILTERIDX_PORT))); Log(("vboxUSBMonSolarisProcessIOCtl: Manufacturer=%s Product=%s Serial=%s\n", USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) : "<null>", USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) : "<null>", USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) : "<null>")); rc = USBFilterSetMustBePresent(pFilter, USBFILTERIDX_BUS, false /* fMustBePresent */); AssertRC(rc); rc = VBoxUSBFilterAdd(pFilter, pState->Process, &pReq->uId); *pcbReturnedData = cbData; Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: ADD_FILTER (Process:%d) returned %d\n", pState->Process, rc)); break; } case VBOXUSBMON_IOCTL_REMOVE_FILTER: { CHECKRET_MIN_SIZE("REMOVE_FILTER", sizeof(VBOXUSBREQ_REMOVE_FILTER)); VBOXUSBREQ_REMOVE_FILTER *pReq = (VBOXUSBREQ_REMOVE_FILTER *)pvData; rc = VBoxUSBFilterRemove(pState->Process, (uintptr_t)pReq->uId); *pcbReturnedData = 0; Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: REMOVE_FILTER (Process:%d) returned %d\n", pState->Process, rc)); break; } case VBOXUSBMON_IOCTL_RESET_DEVICE: { CHECKRET_MIN_SIZE("RESET_DEVICE", sizeof(VBOXUSBREQ_RESET_DEVICE)); VBOXUSBREQ_RESET_DEVICE *pReq = (VBOXUSBREQ_RESET_DEVICE *)pvData; rc = vboxUSBMonSolarisResetDevice(pReq->szDevicePath, pReq->fReattach); *pcbReturnedData = 0; Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: RESET_DEVICE (Process:%d) returned %d\n", pState->Process, rc)); break; } case VBOXUSBMON_IOCTL_CLIENT_INFO: { CHECKRET_MIN_SIZE("CLIENT_INFO", sizeof(VBOXUSBREQ_CLIENT_INFO)); VBOXUSBREQ_CLIENT_INFO *pReq = (VBOXUSBREQ_CLIENT_INFO *)pvData; rc = vboxUSBMonSolarisClientInfo(pState, pReq); *pcbReturnedData = cbData; Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: CLIENT_INFO (Process:%d) returned %d\n", pState->Process, rc)); break; } case VBOXUSBMON_IOCTL_GET_VERSION: { CHECKRET_MIN_SIZE("GET_VERSION", sizeof(VBOXUSBREQ_GET_VERSION)); PVBOXUSBREQ_GET_VERSION pGetVersionReq = (PVBOXUSBREQ_GET_VERSION)pvData; pGetVersionReq->u32Major = VBOXUSBMON_VERSION_MAJOR; pGetVersionReq->u32Minor = VBOXUSBMON_VERSION_MINOR; *pcbReturnedData = sizeof(VBOXUSBREQ_GET_VERSION); rc = VINF_SUCCESS; Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: GET_VERSION returned %d\n", rc)); break; } default: { LogRel((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: Unknown request (Process:%d) %#x\n", pState->Process, iFunction)); rc = VERR_NOT_SUPPORTED; break; } } return rc; }