VBoxUsbFlt.cpp revision 53725df8236fc78c6f9a79d9d7f0358f6e0de238
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * VBox USB Monitor Device Filtering functionality
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * Copyright (C) 2011 Oracle Corporation
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * available from http://www.virtualbox.org. This file is free software;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * you can redistribute it and/or modify it under the terms of the GNU
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * General Public License (GPL) as published by the Free Software
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync/*******************************************************************************
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync* Header Files *
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync*******************************************************************************/
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * Note: Must match the VID & PID in the USB driver .inf file!!
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync BusQueryDeviceID USB\Vid_80EE&Pid_CAFE
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync BusQueryInstanceID 2
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync BusQueryHardwareIDs USB\Vid_80EE&Pid_CAFE&Rev_0100
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync BusQueryHardwareIDs USB\Vid_80EE&Pid_CAFE
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync BusQueryCompatibleIDs USB\Class_ff&SubClass_00&Prot_00
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync BusQueryCompatibleIDs USB\Class_ff&SubClass_00
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync BusQueryCompatibleIDs USB\Class_ff
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync#define szBusQueryDeviceId L"USB\\Vid_80EE&Pid_CAFE"
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync#define szBusQueryHardwareIDs L"USB\\Vid_80EE&Pid_CAFE&Rev_0100\0USB\\Vid_80EE&Pid_CAFE\0\0"
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync#define szBusQueryCompatibleIDs L"USB\\Class_ff&SubClass_00&Prot_00\0USB\\Class_ff&SubClass_00\0USB\\Class_ff\0\0"
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync/* Possible USB bus driver names. */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync L"\\Driver\\usbhub",
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * state transitions:
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * (we are not filtering this device )
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * ADDED --> UNCAPTURED ------------------------------->-
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * | (we are filtering this device, | (the device is being
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * | waiting for our device driver | re-plugged to perform
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * | to pick it up) | capture-uncapture transition)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * |-> CAPTURING -------------------------------->|---> REPLUGGING -----
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * ^ | (device driver picked | |
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * | | up the device) | (remove cased | (device is removed
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * | ->---> CAPTURED ---------------------->| by "real" removal | the device info is removed form the list)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * | | |------------------->->--> REMOVED
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * |-----------<->---> USED_BY_GUEST ------->|
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * |------------------------<-
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * NOTE: the order of enums DOES MATTER!!
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * Do not blindly modify!! as the code assumes the state is ordered this way.
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsynctypedef enum
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* auxiliary list to be used for gathering devices to be re-plugged
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * only thread that puts the device to the REPLUGGING state can use this list */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* Owning session. Each matched device has an owning session. */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* filter id - if NULL AND device has an owner - the filter is destroyed */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* true iff device is filtered with a one-shot filter */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* The device state. If the non-owner session is requesting the state while the device is grabbed,
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * the USBDEVICESTATE_USED_BY_HOST is returned. */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync#define PVBOXUSBFLT_DEVICE_FROM_LE(_pLe) ( (PVBOXUSBFLT_DEVICE)( ((uint8_t*)(_pLe)) - RT_OFFSETOF(VBOXUSBFLT_DEVICE, GlobalLe) ) )
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync#define PVBOXUSBFLT_DEVICE_FROM_REPLUGGINGLE(_pLe) ( (PVBOXUSBFLT_DEVICE)( ((uint8_t*)(_pLe)) - RT_OFFSETOF(VBOXUSBFLT_DEVICE, RepluggingLe) ) )
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync#define PVBOXUSBFLTCTX_FROM_LE(_pLe) ( (PVBOXUSBFLTCTX)( ((uint8_t*)(_pLe)) - RT_OFFSETOF(VBOXUSBFLTCTX, ListEntry) ) )
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync KeInitializeSpinLock(&g_VBoxUsbFltGlobals.Lock.Lock)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync#define VBOXUSBFLT_LOCK_TERM() do { } while (0)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync KeAcquireSpinLock(&g_VBoxUsbFltGlobals.Lock.Lock, &g_VBoxUsbFltGlobals.Lock.OldIrql);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync KeReleaseSpinLock(&g_VBoxUsbFltGlobals.Lock.Lock, g_VBoxUsbFltGlobals.Lock.OldIrql);
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync#define PVBOXUSBFLT_BLDEV_FROM_LE(_pLe) ( (PVBOXUSBFLT_BLDEV)( ((uint8_t*)(_pLe)) - RT_OFFSETOF(VBOXUSBFLT_BLDEV, ListEntry) ) )
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync /* devices known to misbehave */
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsyncstatic bool vboxUsbFltBlDevMatchLocked(uint16_t idVendor, uint16_t idProduct, uint16_t bcdDevice)
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.BlackDeviceList.Flink;
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync PVBOXUSBFLT_BLDEV pDev = PVBOXUSBFLT_BLDEV_FROM_LE(pEntry);
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync return true;
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync return false;
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsyncstatic NTSTATUS vboxUsbFltBlDevAddLocked(uint16_t idVendor, uint16_t idProduct, uint16_t bcdDevice)
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync if (vboxUsbFltBlDevMatchLocked(idVendor, idProduct, bcdDevice))
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync PVBOXUSBFLT_BLDEV pDev = (PVBOXUSBFLT_BLDEV)VBoxUsbMonMemAllocZ(sizeof (*pDev));
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync InsertHeadList(&g_VBoxUsbFltGlobals.BlackDeviceList, &pDev->ListEntry);
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.BlackDeviceList.Flink;
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsyncstatic void vboxUsbFltBlDevPopulateWithKnownLocked()
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync /* this one halts when trying to get string descriptors from it */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncDECLINLINE(void) vboxUsbFltDevRetain(PVBOXUSBFLT_DEVICE pDevice)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncstatic void vboxUsbFltDevDestroy(PVBOXUSBFLT_DEVICE pDevice)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync Assert(pDevice->enmState == VBOXUSBFLT_DEVSTATE_REMOVED);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncDECLINLINE(void) vboxUsbFltDevRelease(PVBOXUSBFLT_DEVICE pDevice)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncstatic void vboxUsbFltDevOwnerSetLocked(PVBOXUSBFLT_DEVICE pDevice, PVBOXUSBFLTCTX pContext, uintptr_t uFltId, bool fIsOneShot)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncstatic void vboxUsbFltDevOwnerClearLocked(PVBOXUSBFLT_DEVICE pDevice)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync Assert(pDevice->pOwner->cActiveFilters < UINT32_MAX/2);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncstatic void vboxUsbFltDevOwnerUpdateLocked(PVBOXUSBFLT_DEVICE pDevice, PVBOXUSBFLTCTX pContext, uintptr_t uFltId, bool fIsOneShot)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync vboxUsbFltDevOwnerSetLocked(pDevice, pContext, uFltId, fIsOneShot);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncstatic PVBOXUSBFLT_DEVICE vboxUsbFltDevGetLocked(PDEVICE_OBJECT pPdo)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync PVBOXUSBFLT_DEVICE pDevice2 = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry2);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN( pDevice->idVendor != pDevice2->idVendor
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync || pDevice->bcdDevice != pDevice2->bcdDevice, ("duplicate devices in a list!!"));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN( pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync || pDevice->enmState == VBOXUSBFLT_DEVSTATE_UNCAPTURED
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync || pDevice->enmState == VBOXUSBFLT_DEVSTATE_CAPTURING
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync || pDevice->enmState == VBOXUSBFLT_DEVSTATE_CAPTURED
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync || pDevice->enmState == VBOXUSBFLT_DEVSTATE_USED_BY_GUEST,
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ("Invalid device state(%d) for device(0x%p) PDO(0x%p)", pDevice->enmState, pDevice, pDevice->Pdo));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncPVBOXUSBFLT_DEVICE vboxUsbFltDevGet(PDEVICE_OBJECT pPdo)
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("found device (0x%p), state(%d) for PDO(0x%p)", pDevice, pDevice->enmState, pPdo));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("found replugging device (0x%p), state(%d) for PDO(0x%p)", pDevice, pDevice->enmState, pPdo));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncstatic NTSTATUS vboxUsbFltPdoReplug(PDEVICE_OBJECT pDo)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync NTSTATUS Status = VBoxUsbToolIoInternalCtlSendSync(pDo, IOCTL_INTERNAL_USB_CYCLE_PORT, NULL, NULL);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(Status == STATUS_SUCCESS, ("replugging PDO(0x%p) failed Status(0x%x)", pDo, Status));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Replugging PDO(0x%p) done with Status(0x%x)", pDo, Status));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncstatic PVBOXUSBFLTCTX vboxUsbFltDevMatchLocked(PVBOXUSBFLT_DEVICE pDevice, uintptr_t *puId, bool fRemoveFltIfOneShot, bool *pfFilter, bool *pfIsOneShot)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterSetNumExact(&DevFlt, USBFILTERIDX_VENDOR_ID, pDevice->idVendor, true);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterSetNumExact(&DevFlt, USBFILTERIDX_PRODUCT_ID, pDevice->idProduct, true);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterSetNumExact(&DevFlt, USBFILTERIDX_DEVICE_REV, pDevice->bcdDevice, true);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterSetNumExact(&DevFlt, USBFILTERIDX_DEVICE_CLASS, pDevice->bClass, true);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterSetNumExact(&DevFlt, USBFILTERIDX_DEVICE_SUB_CLASS, pDevice->bSubClass, true);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterSetNumExact(&DevFlt, USBFILTERIDX_DEVICE_PROTOCOL, pDevice->bProtocol, true);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterSetStringExact(&DevFlt, USBFILTERIDX_MANUFACTURER_STR, pDevice->szMfgName, true);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterSetStringExact(&DevFlt, USBFILTERIDX_PRODUCT_STR, pDevice->szProduct, true);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterSetStringExact(&DevFlt, USBFILTERIDX_SERIAL_NUMBER_STR, pDevice->szSerial, true);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* Run filters on the thing. */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync PVBOXUSBFLTCTX pOwner = VBoxUSBFilterMatchEx(&DevFlt, puId, fRemoveFltIfOneShot, pfFilter, pfIsOneShot);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncstatic void vboxUsbFltDevStateMarkReplugLocked(PVBOXUSBFLT_DEVICE pDevice)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync vboxUsbFltDevOwnerUpdateLocked(pDevice, NULL, 0, false);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync pDevice->enmState = VBOXUSBFLT_DEVSTATE_REPLUGGING;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncstatic bool vboxUsbFltDevStateIsNotFiltered(PVBOXUSBFLT_DEVICE pDevice)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync return pDevice->enmState == VBOXUSBFLT_DEVSTATE_UNCAPTURED;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncstatic bool vboxUsbFltDevStateIsFiltered(PVBOXUSBFLT_DEVICE pDevice)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync return pDevice->enmState >= VBOXUSBFLT_DEVSTATE_CAPTURING;
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync#define VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS 10000
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncstatic NTSTATUS vboxUsbFltDevPopulate(PVBOXUSBFLT_DEVICE pDevice, PDEVICE_OBJECT pDo /*, BOOLEAN bPopulateNonFilterProps*/)
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Populating Device(0x%p) for PDO(0x%p)", pDevice, pDo));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync pDevDr = (PUSB_DEVICE_DESCRIPTOR)VBoxUsbMonMemAllocZ(sizeof(*pDevDr));
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync Status = VBoxUsbToolGetDescriptor(pDo, pDevDr, sizeof(*pDevDr), USB_DEVICE_DESCRIPTOR_TYPE, 0, 0, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync WARN(("getting device descriptor failed, Status (0x%x)\n", Status));
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync if (vboxUsbFltBlDevMatchLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice))
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync WARN(("found a known black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
67bfa93839cac50828c90f19a00256bf44cc0f33vboxsync LOG(("Device pid=%x vid=%x rev=%x\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* If there are no strings, don't even try to get any string descriptors. */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync if (pDevDr->iSerialNumber || pDevDr->iManufacturer || pDevDr->iProduct)
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync Status = VBoxUsbToolGetLangID(pDo, &langId, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync WARN(("found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice);
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync Status = VBoxUsbToolGetStringDescriptorA(pDo, pDevice->szSerial, sizeof (pDevice->szSerial), pDevDr->iSerialNumber, langId, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync WARN(("found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice);
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync Status = VBoxUsbToolGetStringDescriptorA(pDo, pDevice->szMfgName, sizeof (pDevice->szMfgName), pDevDr->iManufacturer, langId, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync WARN(("found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice);
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync Status = VBoxUsbToolGetStringDescriptorA(pDo, pDevice->szProduct, sizeof (pDevice->szProduct), pDevDr->iProduct, langId, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync WARN(("found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync AssertMsgFailed((__FUNCTION__": IoGetDeviceProperty failed Status (0x%x)\n", Status));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync Ansi.MaximumLength = sizeof(pDevice->szDrvKeyName);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync Status = RtlUnicodeStringToAnsiString(&Ansi, &Unicode, FALSE /* do not allocate */);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync AssertMsgFailed((__FUNCTION__": RtlUnicodeStringToAnsiString failed Status (0x%x)\n", Status));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync Status = VBoxUsbToolGetDeviceSpeed(pDo, &pDevice->fHighSpend);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync AssertMsgFailed((__FUNCTION__": VBoxUsbToolGetDeviceSpeed failed Status (0x%x)\n", Status));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync pDevice->szMfgName, pDevice->szProduct, pDevice->szSerial, langId));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Populating Device(0x%p) for PDO(0x%p) Succeeded", pDevice, pDo));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync } while (0);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Populating Device(0x%p) for PDO(0x%p) Done, Status (0x%x)", pDevice, pDo, Status));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.ContextList.Flink;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync PVBOXUSBFLTCTX pCtx = PVBOXUSBFLTCTX_FROM_LE(pEntry);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* the removed context can not be in a list */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync 0, /* increment*/
ea011c6d420ca798e246c09234845dfdedcda4acvboxsyncstatic bool vboxUsbFltDevCheckReplugLocked(PVBOXUSBFLT_DEVICE pDevice, PVBOXUSBFLTCTX pContext)
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Current Device owner is (0x%p)", pDevice->pOwner));
ea011c6d420ca798e246c09234845dfdedcda4acvboxsync /* check if device is already replugging */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync if (pDevice->enmState <= VBOXUSBFLT_DEVSTATE_ADDED)
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Device (0x%p) is already replugging, return..", pDevice));
ea011c6d420ca798e246c09234845dfdedcda4acvboxsync /* it is, do nothing */
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING,
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ("Device (0x%p) state is NOT REPLUGGING (%d)", pDevice, pDevice->enmState));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync return false;
ea011c6d420ca798e246c09234845dfdedcda4acvboxsync if (pDevice->pOwner && pContext != pDevice->pOwner)
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Device (0x%p) is owned by another context(0x%p), current is(0x%p)", pDevice, pDevice->pOwner, pContext));
ea011c6d420ca798e246c09234845dfdedcda4acvboxsync /* this device is owned by another context, we're not allowed to do anything */
ea011c6d420ca798e246c09234845dfdedcda4acvboxsync return false;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync bool bNeedReplug = false;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync bool fFilter = false;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync bool fIsOneShot = false;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync PVBOXUSBFLTCTX pNewOwner = vboxUsbFltDevMatchLocked(pDevice, &uId,
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync false, /* do not remove a one-shot filter */
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Matching Info: Filter (0x%p), NewOwner(0x%p), fFilter(%d), fIsOneShot(%d)", uId, pNewOwner, (int)fFilter, (int)fIsOneShot));
ea011c6d420ca798e246c09234845dfdedcda4acvboxsync if (pDevice->pOwner && pNewOwner && pDevice->pOwner != pNewOwner)
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Matching: Device (0x%p) is requested another owner(0x%p), current is(0x%p)", pDevice, pNewOwner, pDevice->pOwner));
ea011c6d420ca798e246c09234845dfdedcda4acvboxsync /* the device is owned by another owner, we can not change the owner here */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync return false;
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Matching: Device (0x%p) should NOT be filtered", pDevice));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* the device should NOT be filtered, check the current state */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* no changes */
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Matching: This is a one-shot filter (0x%p), removing..", uId));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* remove a one-shot filter and keep the original filter data */
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(RT_SUCCESS(tmpRc), ("remove filter failed, rc (%d)", tmpRc));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Matching: updating the one-shot owner to (0x%p), fltId(0x%p)", pNewOwner, uId));
ea011c6d420ca798e246c09234845dfdedcda4acvboxsync /* update owner for one-shot if the owner is changed (i.e. assigned) */
ea011c6d420ca798e246c09234845dfdedcda4acvboxsync vboxUsbFltDevOwnerUpdateLocked(pDevice, pNewOwner, uId, true);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Matching: device already has owner (0x%p) assigned", pDevice->pOwner));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Matching: This is NOT a one-shot filter (0x%p), newOwner(0x%p)", uId, pNewOwner));
ea011c6d420ca798e246c09234845dfdedcda4acvboxsync vboxUsbFltDevOwnerUpdateLocked(pDevice, pNewOwner, uId, false);
a2104ee1ba1f25c0efb4ac5d2cd058a7201ec553vboxsync /* the device is currently filtered, we should release it only if
a2104ee1ba1f25c0efb4ac5d2cd058a7201ec553vboxsync * 1. device does not have an owner
a2104ee1ba1f25c0efb4ac5d2cd058a7201ec553vboxsync * 2. it should be released bue to a one-shot filter
a2104ee1ba1f25c0efb4ac5d2cd058a7201ec553vboxsync * 3. it is NOT grabbed by a one-shot filter */
a2104ee1ba1f25c0efb4ac5d2cd058a7201ec553vboxsync if (!pDevice->pOwner || fIsOneShot || !pDevice->fIsFilterOneShot)
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Matching: Device (0x%p) SHOULD be filtered", pDevice));
ea011c6d420ca798e246c09234845dfdedcda4acvboxsync /* the device should be filtered, check the current state */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* the device is filtered */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* no changes */
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Matching: This is a one-shot filter (0x%p), removing..", uId));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* remove a one-shot filter and keep the original filter data */
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(RT_SUCCESS(tmpRc), ("remove filter failed, rc (%d)", tmpRc));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Matching: This is NOT a one-shot filter (0x%p), Owner(0x%p)", uId, pDevice->pOwner));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync vboxUsbFltDevOwnerUpdateLocked(pDevice, pDevice->pOwner, uId, false);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(!pDevice->pOwner, ("device should NOT have owner"));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* the device needs to be filtered, but the owner changes, replug needed */
a2104ee1ba1f25c0efb4ac5d2cd058a7201ec553vboxsync /* the device is currently NOT filtered,
a2104ee1ba1f25c0efb4ac5d2cd058a7201ec553vboxsync * we should replug it only if
a2104ee1ba1f25c0efb4ac5d2cd058a7201ec553vboxsync * 1. device does not have an owner
a2104ee1ba1f25c0efb4ac5d2cd058a7201ec553vboxsync * 2. it should be captured due to a one-shot filter
a2104ee1ba1f25c0efb4ac5d2cd058a7201ec553vboxsync * 3. it is NOT released by a one-shot filter */
a2104ee1ba1f25c0efb4ac5d2cd058a7201ec553vboxsync if (!pDevice->pOwner || fIsOneShot || !pDevice->fIsFilterOneShot)
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Matching: Device needs replugging, marking as such"));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Matching: Device does NOT need replugging"));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_REPLUGGINGLE(pEntry);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("replugging matched PDO(0x%p), pDevice(0x%p)", pDevice->Pdo, pDevice));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync || pDevice->enmState == VBOXUSBFLT_DEVSTATE_REMOVED,
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ("invalid state(0x%x) for device(0x%p)", pDevice->enmState, pDevice));
ea011c6d420ca798e246c09234845dfdedcda4acvboxsyncNTSTATUS VBoxUsbFltFilterCheck(PVBOXUSBFLTCTX pContext)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync UNICODE_STRING szStandardControllerName[RT_ELEMENTS(lpszStandardControllerName)];
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Running filters, Context (0x%p)..", pContext));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync for (int i=0;i<RT_ELEMENTS(lpszStandardControllerName);i++)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync RtlInitUnicodeString(&szStandardControllerName[i], lpszStandardControllerName[i]);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync for (int i = 0; i < 16; i++)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync RtlAnsiStringToUnicodeString(&UnicodeName, &AnsiName, FALSE);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync Status = IoGetDeviceObjectPointer(&UnicodeName, FILE_READ_DATA, &pHubFileObj, &pHubDevObj);
67bfa93839cac50828c90f19a00256bf44cc0f33vboxsync LOG(("IoGetDeviceObjectPointer for %s returned %p %p\n", szHubName, pHubDevObj, pHubFileObj));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync for (int j = 0; j < RT_ELEMENTS(lpszStandardControllerName); ++j)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync if (!RtlCompareUnicodeString(&szStandardControllerName[j], &pHubDevObj->DriverObject->DriverName, TRUE /* case insensitive */))
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync Status = VBoxUsbMonQueryBusRelations(pHubDevObj, pHubFileObj, &pDevRelations);
6cb6e43f3a668826e9b9d00102f7dee1299589e7vboxsync PDEVICE_OBJECT pDevObj = pDevRelations->Objects[k];
6cb6e43f3a668826e9b9d00102f7dee1299589e7vboxsync PVBOXUSBFLT_DEVICE pDevice = vboxUsbFltDevGetLocked(pDevObj);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Found existing device info (0x%p) for PDO 0x%p", pDevice, pDevObj));
ea011c6d420ca798e246c09234845dfdedcda4acvboxsync bool bReplug = vboxUsbFltDevCheckReplugLocked(pDevice, pContext);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync InsertHeadList(&ReplugDevList, &pDevice->RepluggingLe);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* do not dereference object since we will use it later */
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Replug NOT needed for device (0x%p)", pDevice));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN((uint32_t)cReplugPdos < UINT32_MAX/2, ("cReplugPdos(%d) state broken", cReplugPdos));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("NO device info found for PDO 0x%p", pDevObj));
134ae55f7965e893a8437f80e736a5321321645bvboxsync Status = vboxUsbFltDevPopulate(&Device, pDevObj /*, FALSE /* only need filter properties */);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync bool fFilter = false;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync bool fIsOneShot = false;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync PVBOXUSBFLTCTX pCtx = vboxUsbFltDevMatchLocked(&Device, &uId,
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync false, /* do not remove a one-shot filter */
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Matching Info: Filter (0x%p), pCtx(0x%p), fFilter(%d), fIsOneShot(%d)", uId, pCtx, (int)fFilter, (int)fIsOneShot));
53725df8236fc78c6f9a79d9d7f0358f6e0de238vboxsync /* this device needs to be filtered, but it's not,
53725df8236fc78c6f9a79d9d7f0358f6e0de238vboxsync * leave the PDO in array to issue a replug request for it
53725df8236fc78c6f9a79d9d7f0358f6e0de238vboxsync * later on */
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync WARN(("vboxUsbFltDevPopulate for PDO 0x%p failed with Status 0x%x", pDevObj, Status));
53725df8236fc78c6f9a79d9d7f0358f6e0de238vboxsync LOG(("Matching: This device should NOT be filtered"));
53725df8236fc78c6f9a79d9d7f0358f6e0de238vboxsync /* this device should not be filtered, and it's not */
53725df8236fc78c6f9a79d9d7f0358f6e0de238vboxsync ASSERT_WARN((uint32_t)cReplugPdos < UINT32_MAX/2, ("cReplugPdos is %d", cReplugPdos));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("(%d) non-matched PDOs to be replugged", cReplugPdos));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync Status = vboxUsbFltPdoReplug(pDevRelations->Objects[k]);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(Status == STATUS_SUCCESS, ("vboxUsbFltPdoReplug ailed Status(0x%x)", Status));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(!cReplugPdos, ("cReplugPdosreached zero!"));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync WARN(("VBoxUsbMonQueryBusRelations failed for DO(0x%p), Status(0x%x), pDevRelations(0x%p)",
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("DONE Running filters, Context (0x%p)", pContext));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync uint32_t cActiveFilters = pContext->cActiveFilters;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync 0, /* increment*/
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* now re-arrange the filters */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* 1. remove filters */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* 2. check if there are devices owned */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync Assert(pDevice->enmState != VBOXUSBFLT_DEVSTATE_ADDED);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync Assert(pDevice->enmState != VBOXUSBFLT_DEVSTATE_REMOVED);
ea011c6d420ca798e246c09234845dfdedcda4acvboxsync if (vboxUsbFltDevCheckReplugLocked(pDevice, pContext))
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync InsertHeadList(&ReplugDevList, &pDevice->RepluggingLe);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* retain to ensure the device is not removed before we issue a replug */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* keep the PDO alive */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* this should replug all devices that were either skipped or grabbed due to the context's */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync InsertHeadList(&g_VBoxUsbFltGlobals.ContextList, &pContext->ListEntry);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncint VBoxUsbFltAdd(PVBOXUSBFLTCTX pContext, PUSBFILTER pFilter, uintptr_t *pId)
67bfa93839cac50828c90f19a00256bf44cc0f33vboxsync /* LOG the filter details. */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) : "<null>",
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) : "<null>",
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) : "<null>"));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("VBoxUSBClient::addFilter: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x Type%#x\n",
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_CLASS),
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_SUB_CLASS),
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_PROTOCOL),
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* We can't get the bus/port numbers. Ignore them while matching. */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterSetMustBePresent(pFilter, USBFILTERIDX_BUS, false);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBFilterSetMustBePresent(pFilter, USBFILTERIDX_PORT, false);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* Add the filter. */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync int rc = VBoxUSBFilterAdd(pFilter, pContext, &uId);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncint VBoxUsbFltRemove(PVBOXUSBFLTCTX pContext, uintptr_t uId)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(!pDevice->uFltId, ("oneshot filter on device(0x%p): unexpected uFltId(%d)", pDevice, pDevice->uFltId));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(pDevice->pOwner == pContext, ("Device(0x%p) owner(0x%p) not match to (0x%p)", pDevice, pDevice->pOwner, pContext));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(!pDevice->fIsFilterOneShot, ("device(0x%p) is filtered with a oneshot filter", pDevice));
ea011c6d420ca798e246c09234845dfdedcda4acvboxsync /* clear the fIsFilterOneShot flag to ensure the device is replugged on the next VBoxUsbFltFilterCheck call */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncNTSTATUS VBoxUsbFltSetNotifyEvent(PVBOXUSBFLTCTX pContext, HANDLE hEvent)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncstatic USBDEVICESTATE vboxUsbDevGetUserState(PVBOXUSBFLTCTX pContext, PVBOXUSBFLT_DEVICE pDevice)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* the device is filtered, or replugging */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync if (pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING)
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(!pDevice->pOwner, ("replugging device(0x%p) still has an owner(0x%p)", pDevice, pDevice->pOwner));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(!pDevice->uFltId, ("replugging device(0x%p) still has filter(0x%p)", pDevice, pDevice->uFltId));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* no user state for this, we should not return it tu the user */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* the device is filtered, if owner differs from the context, return as USED_BY_HOST */
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(pDevice->pOwner, ("device(0x%p) has noowner", pDevice));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* the id can be null if a filter is removed */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync// Assert(pDevice->uFltId);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Device owner differs from the current context, returning used by host"));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync WARN(("unexpected device state(%d) for device(0x%p)", pDevice->enmState, pDevice));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncstatic void vboxUsbDevToUserInfo(PVBOXUSBFLTCTX pContext, PVBOXUSBFLT_DEVICE pDevice, PUSBSUP_DEVINFO pDevInfo)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync pDevInfo->enmState = vboxUsbDevGetUserState(pContext, pDevice);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync strcpy(pDevInfo->szDrvKeyName, pDevice->szDrvKeyName);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync if (pDevInfo->enmState == USBDEVICESTATE_HELD_BY_PROXY
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync || pDevInfo->enmState == USBDEVICESTATE_USED_BY_GUEST)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* this is the only case where we return the obj name to the client */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncNTSTATUS VBoxUsbFltGetDevice(PVBOXUSBFLTCTX pContext, HVBOXUSBDEVUSR hDevice, PUSBSUP_GETDEV_MON pInfo)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync Assert(pDevice->enmState != VBOXUSBFLT_DEVSTATE_REMOVED);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync Assert(pDevice->enmState != VBOXUSBFLT_DEVSTATE_ADDED);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync USBDEVICESTATE enmUsrState = vboxUsbDevGetUserState(pContext, pDevice);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* this should not occur */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncNTSTATUS VBoxUsbFltPdoAdd(PDEVICE_OBJECT pPdo, BOOLEAN *pbFiltered)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* first check if device is in the a already */
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("found device (0x%p), state(%d) for PDO(0x%p)", pDevice, pDevice->enmState, pPdo));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(pDevice->enmState != VBOXUSBFLT_DEVSTATE_ADDED, ("VBOXUSBFLT_DEVSTATE_ADDED state for device(0x%p)", pDevice));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(pDevice->enmState != VBOXUSBFLT_DEVSTATE_REMOVED, ("VBOXUSBFLT_DEVSTATE_REMOVED state for device(0x%p)", pDevice));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync *pbFiltered = pDevice->enmState >= VBOXUSBFLT_DEVSTATE_CAPTURING;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync pDevice = (PVBOXUSBFLT_DEVICE)VBoxUsbMonMemAllocZ(sizeof (*pDevice));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync NTSTATUS Status = vboxUsbFltDevPopulate(pDevice, pPdo /* , TRUE /* need all props */);
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync WARN(("vboxUsbFltDevPopulate failed, Status 0x%x", Status));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync bool fFilter = false;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync bool fIsOneShot = false;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* (paranoia) re-check the device is still not here */
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("second try: found device (0x%p), state(%d) for PDO(0x%p)", pDevice, pDevice->enmState, pPdo));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(pDevice->enmState != VBOXUSBFLT_DEVSTATE_ADDED, ("second try: VBOXUSBFLT_DEVSTATE_ADDED state for device(0x%p)", pDevice));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(pDevice->enmState != VBOXUSBFLT_DEVSTATE_REMOVED, ("second try: VBOXUSBFLT_DEVSTATE_REMOVED state for device(0x%p)", pDevice));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync *pbFiltered = pTmpDev->enmState >= VBOXUSBFLT_DEVSTATE_CAPTURING;
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Created Device 0x%p for PDO 0x%p", pDevice, pPdo));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync true, /* remove a one-shot filter */
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Matching Info: Filter (0x%p), pCtx(0x%p), fFilter(%d), fIsOneShot(%d)", uId, pCtx, (int)fFilter, (int)fIsOneShot));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Created Device 0x%p should be filtered", pDevice));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("Created Device 0x%p should NOT be filtered", pDevice));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync ASSERT_WARN(!uId == !pCtx, ("invalid uid(0x%p) - ctx(0x%p) pair", uId, pCtx)); /* either both zero or both not */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync pDevice->enmState = VBOXUSBFLT_DEVSTATE_UNCAPTURED;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync vboxUsbFltDevOwnerSetLocked(pDevice, pCtx, fIsOneShot ? 0 : uId, fIsOneShot);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync InsertHeadList(&g_VBoxUsbFltGlobals.DeviceList, &pDevice->GlobalLe);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* do not need to signal anything here -
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * going to do that once the proxy device object starts */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncNTSTATUS VBoxUsbFltPdoAddCompleted(PDEVICE_OBJECT pPdo)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncBOOLEAN VBoxUsbFltPdoIsFiltered(PDEVICE_OBJECT pPdo)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync VBOXUSBFLT_DEVSTATE enmState = VBOXUSBFLT_DEVSTATE_REMOVED;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync PVBOXUSBFLT_DEVICE pDevice = vboxUsbFltDevGetLocked(pPdo);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* the device *should* reappear, do signlling on re-appear only
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * to avoid extra signaling. still there might be a situation
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * when the device will not re-appear if it gets physically removed
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * before it re-appears
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync * @todo: set a timer callback to do a notification from it */
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsyncHVBOXUSBFLTDEV VBoxUsbFltProxyStarted(PDEVICE_OBJECT pPdo)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync if (pDevice->enmState = VBOXUSBFLT_DEVSTATE_CAPTURING)
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("The proxy notified proxy start for the captured device 0x%x\n", pDevice));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync PVBOXUSBFLT_DEVICE pDevice = (PVBOXUSBFLT_DEVICE)hDev;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync if (pDevice->enmState == VBOXUSBFLT_DEVSTATE_CAPTURED
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync || pDevice->enmState == VBOXUSBFLT_DEVSTATE_USED_BY_GUEST)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync /* this is due to devie was physically removed */
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync LOG(("The proxy notified proxy stop for the captured device 0x%x, current state %d\n", pDevice, pDevice->enmState));
85da04c2a4ab34e76410f9c1d83e2fa49800818cvboxsync if(pDevice->enmState != VBOXUSBFLT_DEVSTATE_REPLUGGING)
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync memset(&g_VBoxUsbFltGlobals, 0, sizeof (g_VBoxUsbFltGlobals));
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync InitializeListHead(&g_VBoxUsbFltGlobals.DeviceList);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync InitializeListHead(&g_VBoxUsbFltGlobals.ContextList);
e04781b223e38e3b0c386d7e7c1dd7f30e9f6e90vboxsync InitializeListHead(&g_VBoxUsbFltGlobals.BlackDeviceList);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync bool bBusy = false;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync if (!IsListEmpty(&g_VBoxUsbFltGlobals.ContextList))
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink;
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync } while (0);
97b634ea021fd984782256de4ba4ff31cdb96c47vboxsync for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink;