VirtualBox

Changeset 37047 in vbox


Ignore:
Timestamp:
May 12, 2011 10:29:26 AM (14 years ago)
Author:
vboxsync
Message:

usb: filter misbehaved device dynamic black list

Location:
trunk/src/VBox/HostDrivers/VBoxUSB/win
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxDrvTool.cpp

    r36968 r37047  
    132132}
    133133
     134/* !!!NOTE: the caller MUST be the IRP owner!!! *
     135 * !! one can not post threaded IRPs this way!! */
     136VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolIoPostSyncWithTimeout(PDEVICE_OBJECT pDevObj, PIRP pIrp, ULONG dwTimeoutMs)
     137{
     138    KEVENT Event;
     139    KeInitializeEvent(&Event, NotificationEvent, FALSE);
     140    NTSTATUS Status = VBoxDrvToolIoPostAsync(pDevObj, pIrp, &Event);
     141    if (Status == STATUS_PENDING)
     142    {
     143        LARGE_INTEGER Interval;
     144        PLARGE_INTEGER pInterval = NULL;
     145        if (dwTimeoutMs != RT_INDEFINITE_WAIT)
     146        {
     147            Interval.QuadPart = -(int64_t) dwTimeoutMs /* ms */ * 10000;
     148            pInterval = &Interval;
     149        }
     150
     151        Status = KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, pInterval);
     152        if (Status == STATUS_TIMEOUT)
     153        {
     154#ifdef DEBUG_misha
     155            /* debugging only */
     156            AssertFailed();
     157#endif
     158            if (!IoCancelIrp(pIrp))
     159            {
     160                /* this may happen, but this is something the caller with timeout is not expecting */
     161                AssertFailed();
     162            }
     163
     164            /* wait for the IRP to complete */
     165            KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
     166        }
     167        else
     168        {
     169            Assert(Status == STATUS_SUCCESS);
     170        }
     171
     172        /* by this time the IRP is completed */
     173        Status = pIrp->IoStatus.Status;
     174    }
     175    return Status;
     176}
     177
    134178VBOXDRVTOOL_DECL(VOID) VBoxDrvToolRefWaitEqual(PVBOXDRVTOOL_REF pRef, uint32_t u32Val)
    135179{

  • trunk/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxDrvTool.h

    r36968 r37047  
    7676VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolIoPostAsync(PDEVICE_OBJECT pDevObj, PIRP pIrp, PKEVENT pEvent);
    7777VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolIoPostSync(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     78VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolIoPostSyncWithTimeout(PDEVICE_OBJECT pDevObj, PIRP pIrp, ULONG dwTimeoutMs);
    7879DECLINLINE(NTSTATUS) VBoxDrvToolIoComplete(PIRP pIrp, NTSTATUS Status, ULONG ulInfo)
    7980{

  • trunk/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxUsbTool.cpp

    r36968 r37047  
    8585}
    8686
    87 VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolUrbPost(PDEVICE_OBJECT pDevObj, PURB pUrb)
    88 {
    89     return VBoxUsbToolIoInternalCtlSendSync(pDevObj, IOCTL_INTERNAL_USB_SUBMIT_URB, pUrb, NULL);
    90 }
    91 
    92 VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetDescriptor(PDEVICE_OBJECT pDevObj, void *pvBuffer, int cbBuffer, int Type, int iIndex, int LangId)
     87VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolUrbPost(PDEVICE_OBJECT pDevObj, PURB pUrb, ULONG dwTimeoutMs)
     88{
     89    if (dwTimeoutMs == RT_INDEFINITE_WAIT)
     90        return VBoxUsbToolIoInternalCtlSendSync(pDevObj, IOCTL_INTERNAL_USB_SUBMIT_URB, pUrb, NULL);
     91    return VBoxUsbToolIoInternalCtlSendSyncWithTimeout(pDevObj, IOCTL_INTERNAL_USB_SUBMIT_URB, pUrb, NULL, dwTimeoutMs);
     92}
     93
     94VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetDescriptor(PDEVICE_OBJECT pDevObj, void *pvBuffer, int cbBuffer, int Type, int iIndex, int LangId, ULONG dwTimeoutMs)
    9395{
    9496    NTSTATUS Status;
    … …  
    100102        return STATUS_INSUFFICIENT_RESOURCES;
    101103    }
     104
     105    PUSB_COMMON_DESCRIPTOR pCmn = (PUSB_COMMON_DESCRIPTOR)pvBuffer;
     106    pCmn->bLength = cbBuffer;
     107    pCmn->bDescriptorType = Type;
    102108
    103109    pUrb->UrbHeader.Function = URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE;
    … …  
    109115    pUrb->UrbControlDescriptorRequest.LanguageId           = (USHORT)LangId;
    110116
    111     Status = VBoxUsbToolUrbPost(pDevObj, pUrb);
     117    Status = VBoxUsbToolUrbPost(pDevObj, pUrb, dwTimeoutMs);
    112118#ifdef DEBUG_misha
    113119    Assert(Status == STATUS_SUCCESS);
    … …  
    129135}
    130136
    131 VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetStringDescriptorA(PDEVICE_OBJECT pDevObj, char *pResult, ULONG cbResult, int iIndex, int LangId)
     137VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetStringDescriptorA(PDEVICE_OBJECT pDevObj, char *pResult, ULONG cbResult, int iIndex, int LangId, ULONG dwTimeoutMs)
    132138{
    133139    char aBuf[MAXIMUM_USB_STRING_LENGTH];
    … …  
    143149    pDr->bDescriptorType = USB_STRING_DESCRIPTOR_TYPE;
    144150
    145     NTSTATUS Status = VBoxUsbToolGetDescriptor(pDevObj, pDr, cbBuf, USB_STRING_DESCRIPTOR_TYPE, iIndex, LangId);
     151    NTSTATUS Status = VBoxUsbToolGetDescriptor(pDevObj, pDr, cbBuf, USB_STRING_DESCRIPTOR_TYPE, iIndex, LangId, dwTimeoutMs);
    146152    if (NT_SUCCESS(Status))
    147153    {
    … …  
    175181}
    176182
    177 VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetLangID(PDEVICE_OBJECT pDevObj, int *pLangId)
     183VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetLangID(PDEVICE_OBJECT pDevObj, int *pLangId, ULONG dwTimeoutMs)
    178184{
    179185    char aBuf[MAXIMUM_USB_STRING_LENGTH];
    … …  
    189195    pDr->bDescriptorType = USB_STRING_DESCRIPTOR_TYPE;
    190196
    191     NTSTATUS Status = VBoxUsbToolGetDescriptor(pDevObj, pDr, cbBuf, USB_STRING_DESCRIPTOR_TYPE, 0, 0);
     197    NTSTATUS Status = VBoxUsbToolGetDescriptor(pDevObj, pDr, cbBuf, USB_STRING_DESCRIPTOR_TYPE, 0, 0, dwTimeoutMs);
    192198    if (NT_SUCCESS(Status))
    193199    {
    … …  
    260266    pUrb->UrbPipeRequest.Reserved = 0;
    261267
    262     NTSTATUS Status = VBoxUsbToolUrbPost(pDevObj, pUrb);
     268    NTSTATUS Status = VBoxUsbToolUrbPost(pDevObj, pUrb, RT_INDEFINITE_WAIT);
    263269    if (!NT_SUCCESS(Status) || !USBD_SUCCESS(pUrb->UrbHeader.Status))
    264270    {
    … …  
    287293    pSl->Parameters.Others.Argument2 = NULL;
    288294
    289     NTSTATUS Status = VBoxUsbToolUrbPost(pDevObj, (PURB)&Urb);
     295    NTSTATUS Status = VBoxUsbToolUrbPost(pDevObj, (PURB)&Urb, RT_INDEFINITE_WAIT);
    290296    Assert(NT_SUCCESS(Status));
    291297    if (NT_SUCCESS(Status))
    … …  
    307313    UsbBuildSelectConfigurationRequest(pUrb, (USHORT)cbUrb, NULL);
    308314
    309     NTSTATUS Status = VBoxUsbToolUrbPost(pDevObj, pUrb);
     315    NTSTATUS Status = VBoxUsbToolUrbPost(pDevObj, pUrb, RT_INDEFINITE_WAIT);
    310316    Assert(NT_SUCCESS(Status));
    311317
    312318    VBoxUsbToolUrbFree(pUrb);
     319
     320    return Status;
     321}
     322
     323VBOXUSBTOOL_DECL(PIRP) VBoxUsbToolIoBuildAsyncInternalCtl(PDEVICE_OBJECT pDevObj, ULONG uCtl, void *pvArg1, void *pvArg2)
     324{
     325    PIRP pIrp = IoAllocateIrp(pDevObj->StackSize, FALSE);
     326    Assert(pIrp);
     327    if (!pIrp)
     328    {
     329        return NULL;
     330    }
     331
     332    pIrp->IoStatus.Status = STATUS_SUCCESS;
     333    pIrp->IoStatus.Information = NULL;
     334
     335    PIO_STACK_LOCATION pSl = IoGetNextIrpStackLocation(pIrp);
     336    pSl->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
     337    pSl->MinorFunction = 0;
     338    pSl->Parameters.DeviceIoControl.IoControlCode = uCtl;
     339    pSl->Parameters.Others.Argument1 = pvArg1;
     340    pSl->Parameters.Others.Argument2 = pvArg2;
     341    return pIrp;
     342}
     343
     344VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolIoInternalCtlSendSyncWithTimeout(PDEVICE_OBJECT pDevObj, ULONG uCtl, void *pvArg1, void *pvArg2, ULONG dwTimeoutMs)
     345{
     346    /* since we're going to cancel the irp on timeout, we should allocate our own IRP rather than using the threaded one
     347     * */
     348    PIRP pIrp = VBoxUsbToolIoBuildAsyncInternalCtl(pDevObj, uCtl, pvArg1, pvArg2);
     349    if (!pIrp)
     350    {
     351        return STATUS_INSUFFICIENT_RESOURCES;
     352    }
     353
     354    NTSTATUS Status = VBoxDrvToolIoPostSyncWithTimeout(pDevObj, pIrp, dwTimeoutMs);
     355
     356    IoFreeIrp(pIrp);
    313357
    314358    return Status;

  • trunk/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxUsbTool.h

    r36968 r37047  
    4747VBOXUSBTOOL_DECL(PURB) VBoxUsbToolUrbReinit(PURB pUrb, USHORT cbSize, USHORT u16Function);
    4848VBOXUSBTOOL_DECL(VOID) VBoxUsbToolUrbFree(PURB pUrb);
    49 VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolUrbPost(PDEVICE_OBJECT pDevObj, PURB pUrb);
    50 VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetDescriptor(PDEVICE_OBJECT pDevObj, void *pvBuffer, int cbBuffer, int Type, int iIndex, int LangId);
    51 VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetStringDescriptorA(PDEVICE_OBJECT pDevObj, char *pResult, ULONG cbResult, int iIndex, int LangId);
    52 VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetLangID(PDEVICE_OBJECT pDevObj, int *pLangId);
     49VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolUrbPost(PDEVICE_OBJECT pDevObj, PURB pUrb, ULONG dwTimeoutMs);
     50VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetDescriptor(PDEVICE_OBJECT pDevObj, void *pvBuffer, int cbBuffer, int Type, int iIndex, int LangId, ULONG dwTimeoutMs);
     51VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetStringDescriptorA(PDEVICE_OBJECT pDevObj, char *pResult, ULONG cbResult, int iIndex, int LangId, ULONG dwTimeoutMs);
     52VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetLangID(PDEVICE_OBJECT pDevObj, int *pLangId, ULONG dwTimeoutMs);
    5353VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetDeviceSpeed(PDEVICE_OBJECT pDevObj, BOOLEAN *pbIsHigh);
    5454VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolPipeClear(PDEVICE_OBJECT pDevObj, HANDLE hPipe, bool fReset);
    … …  
    5757VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolIoInternalCtlSendAsync(PDEVICE_OBJECT pDevObj, ULONG uCtl, void *pvArg1, void *pvArg2, PKEVENT pEvent, PIO_STATUS_BLOCK pIoStatus);
    5858VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolIoInternalCtlSendSync(PDEVICE_OBJECT pDevObj, ULONG uCtl, void *pvArg1, void *pvArg2);
     59VBOXUSBTOOL_DECL(PIRP) VBoxUsbToolIoBuildAsyncInternalCtl(PDEVICE_OBJECT pDevObj, ULONG uCtl, void *pvArg1, void *pvArg2);
     60VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolIoInternalCtlSendSyncWithTimeout(PDEVICE_OBJECT pDevObj, ULONG uCtl, void *pvArg1, void *pvArg2, ULONG dwTimeoutMs);
    5961VBOXUSBTOOL_DECL(VOID) VBoxUsbToolStringDescriptorToUnicodeString(PUSB_STRING_DESCRIPTOR pDr, PUNICODE_STRING pUnicode);
    6062

  • trunk/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbRt.cpp

    r36968 r37047  
    301301    {
    302302        memset(pDevExt->Rt.devdescr, 0, sizeof (USB_DEVICE_DESCRIPTOR));
    303         Status = VBoxUsbToolGetDescriptor(pDevExt->pLowerDO, pDevExt->Rt.devdescr, sizeof (USB_DEVICE_DESCRIPTOR), USB_DEVICE_DESCRIPTOR_TYPE, 0, 0);
     303        Status = VBoxUsbToolGetDescriptor(pDevExt->pLowerDO, pDevExt->Rt.devdescr, sizeof (USB_DEVICE_DESCRIPTOR), USB_DEVICE_DESCRIPTOR_TYPE, 0, 0, RT_INDEFINITE_WAIT);
    304304        if (NT_SUCCESS(Status))
    305305        {
    … …  
    312312                for (; i < pDevExt->Rt.devdescr->bNumConfigurations; ++i)
    313313                {
    314                     Status = VBoxUsbToolGetDescriptor(pDevExt->pLowerDO, pDr, sizeof (USB_CONFIGURATION_DESCRIPTOR), USB_CONFIGURATION_DESCRIPTOR_TYPE, i, 0);
     314                    Status = VBoxUsbToolGetDescriptor(pDevExt->pLowerDO, pDr, sizeof (USB_CONFIGURATION_DESCRIPTOR), USB_CONFIGURATION_DESCRIPTOR_TYPE, i, 0, RT_INDEFINITE_WAIT);
    315315                    if (!NT_SUCCESS(Status))
    316316                    {
    … …  
    326326                    }
    327327
    328                     Status = VBoxUsbToolGetDescriptor(pDevExt->pLowerDO, pDevExt->Rt.cfgdescr[i], uTotalLength, USB_CONFIGURATION_DESCRIPTOR_TYPE, i, 0);
     328                    Status = VBoxUsbToolGetDescriptor(pDevExt->pLowerDO, pDevExt->Rt.cfgdescr[i], uTotalLength, USB_CONFIGURATION_DESCRIPTOR_TYPE, i, 0, RT_INDEFINITE_WAIT);
    329329                    if (!NT_SUCCESS(Status))
    330330                    {
    … …  
    428428    if (pDr)
    429429    {
    430         Status = VBoxUsbToolGetDescriptor(pDevExt->pLowerDO, pDr, sizeof(*pDr), USB_DEVICE_DESCRIPTOR_TYPE, 0, 0);
     430        Status = VBoxUsbToolGetDescriptor(pDevExt->pLowerDO, pDr, sizeof(*pDr), USB_DEVICE_DESCRIPTOR_TYPE, 0, 0, RT_INDEFINITE_WAIT);
    431431        if (NT_SUCCESS(Status))
    432432        {
    … …  
    443443            {
    444444                int langId;
    445                 Status = VBoxUsbToolGetLangID(pDevExt->pLowerDO, &langId);
     445                Status = VBoxUsbToolGetLangID(pDevExt->pLowerDO, &langId, RT_INDEFINITE_WAIT);
    446446                if (NT_SUCCESS(Status))
    447447                {
    448                     Status = VBoxUsbToolGetStringDescriptorA(pDevExt->pLowerDO, pDevExt->Rt.szSerial, sizeof (pDevExt->Rt.szSerial), pDr->iSerialNumber, langId);
     448                    Status = VBoxUsbToolGetStringDescriptorA(pDevExt->pLowerDO, pDevExt->Rt.szSerial, sizeof (pDevExt->Rt.szSerial), pDr->iSerialNumber, langId, RT_INDEFINITE_WAIT);
    449449                }
    450450                else
    … …  
    572572        pUrb->UrbSelectConfiguration.ConfigurationDescriptor = NULL;
    573573
    574         Status = VBoxUsbToolUrbPost(pDevExt->pLowerDO, pUrb);
     574        Status = VBoxUsbToolUrbPost(pDevExt->pLowerDO, pUrb, RT_INDEFINITE_WAIT);
    575575        if(NT_SUCCESS(Status) && USBD_SUCCESS(pUrb->UrbHeader.Status))
    576576        {
    … …  
    618618        if (pUrb)
    619619        {
    620             Status = VBoxUsbToolUrbPost(pDevExt->pLowerDO, pUrb);
     620            Status = VBoxUsbToolUrbPost(pDevExt->pLowerDO, pUrb, RT_INDEFINITE_WAIT);
    621621            if (NT_SUCCESS(Status) && USBD_SUCCESS(pUrb->UrbHeader.Status))
    622622            {
    … …  
    815815            pUrb->UrbSelectInterface.Interface.Length = GET_USBD_INTERFACE_SIZE(pIfDr->bNumEndpoints);
    816816
    817             Status = VBoxUsbToolUrbPost(pDevExt->pLowerDO, pUrb);
     817            Status = VBoxUsbToolUrbPost(pDevExt->pLowerDO, pUrb, RT_INDEFINITE_WAIT);
    818818            if (NT_SUCCESS(Status) && USBD_SUCCESS(pUrb->UrbHeader.Status))
    819819            {

  • trunk/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbFlt.cpp

    r37042 r37047  
    150150    KeReleaseSpinLock(&g_VBoxUsbFltGlobals.Lock.Lock, g_VBoxUsbFltGlobals.Lock.OldIrql);
    151151
     152
     153typedef struct VBOXUSBFLT_BLDEV
     154{
     155    LIST_ENTRY ListEntry;
     156    uint16_t   idVendor;
     157    uint16_t   idProduct;
     158    uint16_t   bcdDevice;
     159} VBOXUSBFLT_BLDEV, *PVBOXUSBFLT_BLDEV;
     160
     161#define PVBOXUSBFLT_BLDEV_FROM_LE(_pLe) ( (PVBOXUSBFLT_BLDEV)( ((uint8_t*)(_pLe)) - RT_OFFSETOF(VBOXUSBFLT_BLDEV, ListEntry) ) )
     162
    152163typedef struct VBOXUSBFLTGLOBALS
    153164{
    154165    LIST_ENTRY DeviceList;
    155166    LIST_ENTRY ContextList;
     167    /* devices known to misbehave */
     168    LIST_ENTRY BlackDeviceList;
    156169    VBOXUSBFLT_LOCK Lock;
    157170} VBOXUSBFLTGLOBALS, *PVBOXUSBFLTGLOBALS;
    158171static VBOXUSBFLTGLOBALS g_VBoxUsbFltGlobals;
     172
     173static bool vboxUsbFltBlDevMatchLocked(uint16_t idVendor, uint16_t idProduct, uint16_t bcdDevice)
     174{
     175    for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.BlackDeviceList.Flink;
     176            pEntry != &g_VBoxUsbFltGlobals.BlackDeviceList;
     177            pEntry = pEntry->Flink)
     178    {
     179        PVBOXUSBFLT_BLDEV pDev = PVBOXUSBFLT_BLDEV_FROM_LE(pEntry);
     180        if (pDev->idVendor != idVendor)
     181            continue;
     182        if (pDev->idProduct != idProduct)
     183            continue;
     184        if (pDev->bcdDevice != bcdDevice)
     185            continue;
     186
     187        return true;
     188    }
     189    return false;
     190}
     191
     192static NTSTATUS vboxUsbFltBlDevAddLocked(uint16_t idVendor, uint16_t idProduct, uint16_t bcdDevice)
     193{
     194    if (vboxUsbFltBlDevMatchLocked(idVendor, idProduct, bcdDevice))
     195        return STATUS_SUCCESS;
     196    PVBOXUSBFLT_BLDEV pDev = (PVBOXUSBFLT_BLDEV)VBoxUsbMonMemAllocZ(sizeof (*pDev));
     197    if (!pDev)
     198    {
     199        AssertFailed();
     200        return STATUS_INSUFFICIENT_RESOURCES;
     201    }
     202
     203    pDev->idVendor = idVendor;
     204    pDev->idProduct = idProduct;
     205    pDev->bcdDevice = bcdDevice;
     206    InsertHeadList(&g_VBoxUsbFltGlobals.BlackDeviceList, &pDev->ListEntry);
     207    return STATUS_SUCCESS;
     208}
     209
     210static void vboxUsbFltBlDevClearLocked()
     211{
     212    PLIST_ENTRY pNext;
     213    for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.BlackDeviceList.Flink;
     214            pEntry != &g_VBoxUsbFltGlobals.BlackDeviceList;
     215            pEntry = pNext)
     216    {
     217        pNext = pEntry->Flink;
     218        VBoxUsbMonMemFree(pEntry);
     219    }
     220}
     221
     222static void vboxUsbFltBlDevPopulateWithKnownLocked()
     223{
     224    /* this one halts when trying to get string descriptors from it */
     225    vboxUsbFltBlDevAddLocked(0x5ac, 0x921c, 0x115);
     226}
     227
    159228
    160229DECLINLINE(void) vboxUsbFltDevRetain(PVBOXUSBFLT_DEVICE pDevice)
    … …  
    217286static PVBOXUSBFLT_DEVICE vboxUsbFltDevGetLocked(PDEVICE_OBJECT pPdo)
    218287{
    219 #ifdef DEBUG_mista
     288#ifdef DEBUG_misha
    220289    for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink;
    221290            pEntry != &g_VBoxUsbFltGlobals.DeviceList;
    … …  
    315384}
    316385
     386#define VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS 10000
     387
    317388static NTSTATUS vboxUsbFltDevPopulate(PVBOXUSBFLT_DEVICE pDevice, PDEVICE_OBJECT pDo /*, BOOLEAN bPopulateNonFilterProps*/)
    318389{
    … …  
    331402    do
    332403    {
    333         Status = VBoxUsbToolGetDescriptor(pDo, pDevDr, sizeof(*pDevDr), USB_DEVICE_DESCRIPTOR_TYPE, 0, 0);
     404        Status = VBoxUsbToolGetDescriptor(pDo, pDevDr, sizeof(*pDevDr), USB_DEVICE_DESCRIPTOR_TYPE, 0, 0, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS);
    334405        if (!NT_SUCCESS(Status))
    335406        {
    336             LogRel(("VBoxUSBGetDeviceDescription: getting device descriptor failed\n"));
     407            LogRel((__FUNCTION__": getting device descriptor failed\n"));
     408            break;
     409        }
     410
     411        if (vboxUsbFltBlDevMatchLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice))
     412        {
     413            LogRel((__FUNCTION__": found a known black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
     414#ifdef DEBUG_misha
     415            AssertFailed();
     416#endif
     417            Status = STATUS_UNSUCCESSFUL;
    337418            break;
    338419        }
    … …  
    354435            int             langId;
    355436
    356             Status = VBoxUsbToolGetLangID(pDo, &langId);
     437            Status = VBoxUsbToolGetLangID(pDo, &langId, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS);
    357438            if (!NT_SUCCESS(Status))
    358439            {
    359440                AssertMsgFailed((__FUNCTION__": reading language ID failed\n"));
     441                if (Status == STATUS_CANCELLED)
     442                {
     443                    AssertMsgFailed((__FUNCTION__": found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
     444                    vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice);
     445                    Status = STATUS_UNSUCCESSFUL;
     446                }
    360447                break;
    361448            }
    … …  
    363450            if (pDevDr->iSerialNumber)
    364451            {
    365                 Status = VBoxUsbToolGetStringDescriptorA(pDo, pDevice->szSerial, sizeof (pDevice->szSerial), pDevDr->iSerialNumber, langId);
     452                Status = VBoxUsbToolGetStringDescriptorA(pDo, pDevice->szSerial, sizeof (pDevice->szSerial), pDevDr->iSerialNumber, langId, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS);
    366453                if (!NT_SUCCESS(Status))
    367454                {
    368455                    AssertMsgFailed((__FUNCTION__": reading serial number failed\n"));
     456                    if (Status == STATUS_CANCELLED)
     457                    {
     458                        AssertMsgFailed((__FUNCTION__": found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
     459                        vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice);
     460                        Status = STATUS_UNSUCCESSFUL;
     461                    }
    369462                    break;
    370463                }
    … …  
    373466            if (pDevDr->iManufacturer)
    374467            {
    375                 Status = VBoxUsbToolGetStringDescriptorA(pDo, pDevice->szMfgName, sizeof (pDevice->szMfgName), pDevDr->iManufacturer, langId);
     468                Status = VBoxUsbToolGetStringDescriptorA(pDo, pDevice->szMfgName, sizeof (pDevice->szMfgName), pDevDr->iManufacturer, langId, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS);
    376469                if (!NT_SUCCESS(Status))
    377470                {
    378471                    AssertMsgFailed((__FUNCTION__": reading manufacturer name failed\n"));
     472                    if (Status == STATUS_CANCELLED)
     473                    {
     474                        AssertMsgFailed((__FUNCTION__": found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
     475                        vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice);
     476                        Status = STATUS_UNSUCCESSFUL;
     477                    }
    379478                    break;
    380479                }
    … …  
    383482            if (pDevDr->iProduct)
    384483            {
    385                 Status = VBoxUsbToolGetStringDescriptorA(pDo, pDevice->szProduct, sizeof (pDevice->szProduct), pDevDr->iProduct, langId);
     484                Status = VBoxUsbToolGetStringDescriptorA(pDo, pDevice->szProduct, sizeof (pDevice->szProduct), pDevDr->iProduct, langId, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS);
    386485                if (!NT_SUCCESS(Status))
    387486                {
    388487                    AssertMsgFailed((__FUNCTION__": reading product name failed\n"));
     488                    if (Status == STATUS_CANCELLED)
     489                    {
     490                        AssertMsgFailed((__FUNCTION__": found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
     491                        vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice);
     492                        Status = STATUS_UNSUCCESSFUL;
     493                    }
    389494                    break;
    390495                }
    … …  
    12181323    InitializeListHead(&g_VBoxUsbFltGlobals.DeviceList);
    12191324    InitializeListHead(&g_VBoxUsbFltGlobals.ContextList);
     1325    InitializeListHead(&g_VBoxUsbFltGlobals.BlackDeviceList);
     1326    vboxUsbFltBlDevPopulateWithKnownLocked();
    12201327    VBOXUSBFLT_LOCK_INIT();
    12211328    return STATUS_SUCCESS;
    … …  
    12691376        vboxUsbFltDevRelease(pDevice);
    12701377    }
     1378
     1379    vboxUsbFltBlDevClearLocked();
     1380
    12711381    VBOXUSBFLT_LOCK_TERM();
    12721382
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette