mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
708 lines
17 KiB
708 lines
17 KiB
//---------------------------------------------------------------------------
|
|
//
|
|
// Module: fn.cpp
|
|
//
|
|
// Description:
|
|
//
|
|
//
|
|
//@@BEGIN_MSINTERNAL
|
|
// Development Team:
|
|
// Mike McLaughlin
|
|
//
|
|
// History: Date Author Comment
|
|
//
|
|
// To Do: Date Author Comment
|
|
//
|
|
//@@END_MSINTERNAL
|
|
//
|
|
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
|
|
// KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
|
|
// PURPOSE.
|
|
//
|
|
// Copyright (c) 1996-1999 Microsoft Corporation. All Rights Reserved.
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
#include "common.h"
|
|
|
|
EXTERN_C VOID KeAttachProcess(PVOID);
|
|
EXTERN_C VOID KeDetachProcess(VOID);
|
|
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
PLIST_FILTER_NODE gplstFilterNode = NULL;
|
|
PLIST_MULTI_LOGICAL_FILTER_NODE gplstLogicalFilterNode = NULL;
|
|
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
NTSTATUS
|
|
InitializeFilterNode()
|
|
{
|
|
if(gplstFilterNode == NULL) {
|
|
gplstFilterNode = new LIST_FILTER_NODE;
|
|
if(gplstFilterNode == NULL) {
|
|
return(STATUS_INSUFFICIENT_RESOURCES);
|
|
}
|
|
}
|
|
if(gplstLogicalFilterNode == NULL) {
|
|
gplstLogicalFilterNode = new LIST_MULTI_LOGICAL_FILTER_NODE;
|
|
if(gplstLogicalFilterNode == NULL) {
|
|
return(STATUS_INSUFFICIENT_RESOURCES);
|
|
}
|
|
}
|
|
return(STATUS_SUCCESS);
|
|
}
|
|
|
|
#pragma PAGEABLE_CODE
|
|
#pragma PAGEABLE_DATA
|
|
|
|
VOID
|
|
UninitializeFilterNode()
|
|
{
|
|
PFILTER_NODE pFilterNode;
|
|
|
|
FOR_EACH_LIST_ITEM_DELETE(gplstFilterNode, pFilterNode) {
|
|
if (pFilterNode->pDeviceNode) {
|
|
pFilterNode->pDeviceNode->pFilterNode=NULL;
|
|
}
|
|
delete pFilterNode;
|
|
DELETE_LIST_ITEM(gplstFilterNode);
|
|
} END_EACH_LIST_ITEM
|
|
|
|
delete gplstFilterNode;
|
|
gplstFilterNode = NULL;
|
|
delete gplstLogicalFilterNode;
|
|
gplstLogicalFilterNode = NULL;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
CFilterNode::CFilterNode(
|
|
ULONG fulType
|
|
)
|
|
{
|
|
ASSERT(gplstFilterNode != NULL);
|
|
SetType(fulType);
|
|
AddListEnd(gplstFilterNode);
|
|
DPF2(60, "CFilterNode: %08x %s", this, DumpName());
|
|
}
|
|
|
|
CFilterNode::~CFilterNode(
|
|
)
|
|
{
|
|
PFILTER_NODE pFilterNode;
|
|
|
|
Assert(this);
|
|
DPF2(60, "~CFilterNode: %08x %s", this, DumpName());
|
|
RemoveListCheck();
|
|
if (pDeviceNode) {
|
|
pDeviceNode->pFilterNode = NULL;
|
|
}
|
|
if (pFileObject) {
|
|
::ObDereferenceObject(pFileObject);
|
|
pFileObject = NULL;
|
|
}
|
|
delete pDeviceNode;
|
|
|
|
FOR_EACH_LIST_ITEM(gplstFilterNode, pFilterNode) {
|
|
pFilterNode->lstConnectedFilterNode.RemoveList(this);
|
|
} END_EACH_LIST_ITEM
|
|
|
|
// Free all other memory
|
|
lstFreeMem.EnumerateList(CListDataItem::Destroy);
|
|
}
|
|
|
|
NTSTATUS
|
|
CFilterNode::Create(
|
|
PWSTR pwstrDeviceInterface
|
|
)
|
|
{
|
|
PFILTER_NODE_INSTANCE pFilterNodeInstance = NULL;
|
|
PKEY_VALUE_FULL_INFORMATION pkvfi = NULL;
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
HANDLE hkeyDeviceClass = NULL;
|
|
HANDLE hkeySysaudio = NULL;
|
|
UNICODE_STRING ustrFilterName;
|
|
KSPROPERTY PropertyComponentId;
|
|
KSCOMPONENTID ComponentId;
|
|
ULONG BytesReturned;
|
|
PFILE_OBJECT pFileObject;
|
|
|
|
|
|
this->pwstrDeviceInterface = new WCHAR[wcslen(pwstrDeviceInterface) + 1];
|
|
if(this->pwstrDeviceInterface == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
wcscpy(this->pwstrDeviceInterface, pwstrDeviceInterface);
|
|
|
|
Status = lstFreeMem.AddList(this->pwstrDeviceInterface);
|
|
if(!NT_SUCCESS(Status)) {
|
|
Trap();
|
|
delete this->pwstrDeviceInterface;
|
|
goto exit;
|
|
}
|
|
|
|
Status = CFilterNodeInstance::Create(&pFilterNodeInstance, this);
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
pFileObject = pFilterNodeInstance->pFileObject;
|
|
|
|
// Get the filter's friendly name
|
|
RtlInitUnicodeString(&ustrFilterName, this->pwstrDeviceInterface);
|
|
|
|
Status = IoOpenDeviceInterfaceRegistryKey(
|
|
&ustrFilterName,
|
|
KEY_READ,
|
|
&hkeyDeviceClass);
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
|
|
Status = OpenRegistryKey(L"Sysaudio", &hkeySysaudio, hkeyDeviceClass);
|
|
if(NT_SUCCESS(Status)) {
|
|
Status = QueryRegistryValue(hkeySysaudio, L"Disabled", &pkvfi);
|
|
if(NT_SUCCESS(Status)) {
|
|
if(pkvfi->Type == REG_DWORD) {
|
|
if(*((PULONG)(((PUCHAR)pkvfi) + pkvfi->DataOffset))) {
|
|
Status = STATUS_SERVER_DISABLED;
|
|
delete pkvfi;
|
|
goto exit;
|
|
}
|
|
}
|
|
delete pkvfi;
|
|
}
|
|
Status = QueryRegistryValue(hkeySysaudio, L"Device", &pkvfi);
|
|
if(NT_SUCCESS(Status)) {
|
|
if(pkvfi->Type == REG_SZ && pkvfi->DataLength > 0) {
|
|
Status = lstFreeMem.AddList(pkvfi);
|
|
if(!NT_SUCCESS(Status)) {
|
|
Trap();
|
|
delete pkvfi;
|
|
goto exit;
|
|
}
|
|
Status = AddDeviceInterfaceMatch(
|
|
(PWSTR)(((PUCHAR)pkvfi) + pkvfi->DataOffset));
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
Trap();
|
|
delete pkvfi;
|
|
goto exit;
|
|
}
|
|
}
|
|
else {
|
|
delete pkvfi;
|
|
}
|
|
}
|
|
|
|
Status = QueryRegistryValue(hkeySysaudio, L"Order", &pkvfi);
|
|
if(NT_SUCCESS(Status)) {
|
|
if(pkvfi->Type == REG_DWORD) {
|
|
ulOrder = *((PULONG)(((PUCHAR)pkvfi) + pkvfi->DataOffset));
|
|
}
|
|
delete pkvfi;
|
|
}
|
|
|
|
Status = QueryRegistryValue(hkeySysaudio, L"Capture", &pkvfi);
|
|
if(NT_SUCCESS(Status)) {
|
|
if(pkvfi->Type == REG_DWORD) {
|
|
if(*((PULONG)(((PUCHAR)pkvfi) + pkvfi->DataOffset))) {
|
|
ulFlags |= FN_FLAGS_CAPTURE;
|
|
}
|
|
else {
|
|
ulFlags |= FN_FLAGS_NO_CAPTURE;
|
|
}
|
|
}
|
|
delete pkvfi;
|
|
}
|
|
|
|
Status = QueryRegistryValue(hkeySysaudio, L"Render", &pkvfi);
|
|
if(NT_SUCCESS(Status)) {
|
|
if(pkvfi->Type == REG_DWORD) {
|
|
if(*((PULONG)(((PUCHAR)pkvfi) + pkvfi->DataOffset))) {
|
|
ulFlags |= FN_FLAGS_RENDER;
|
|
}
|
|
else {
|
|
ulFlags |= FN_FLAGS_NO_RENDER;
|
|
}
|
|
}
|
|
delete pkvfi;
|
|
}
|
|
}
|
|
|
|
Status = QueryRegistryValue(hkeyDeviceClass, L"FriendlyName", &pkvfi);
|
|
if(NT_SUCCESS(Status)) {
|
|
if(pkvfi->Type == REG_SZ && pkvfi->DataLength > 0) {
|
|
Status = lstFreeMem.AddList(pkvfi);
|
|
if(!NT_SUCCESS(Status)) {
|
|
Trap();
|
|
delete pkvfi;
|
|
goto exit;
|
|
}
|
|
pwstrFriendlyName = (PWSTR)(((PUCHAR)pkvfi) + pkvfi->DataOffset);
|
|
}
|
|
else {
|
|
delete pkvfi;
|
|
}
|
|
}
|
|
|
|
// Get the component Id of the filter
|
|
PropertyComponentId.Set = KSPROPSETID_General;
|
|
PropertyComponentId.Id = KSPROPERTY_GENERAL_COMPONENTID;
|
|
PropertyComponentId.Flags = KSPROPERTY_TYPE_GET;
|
|
|
|
Status = KsSynchronousIoControlDevice(
|
|
pFileObject,
|
|
KernelMode,
|
|
IOCTL_KS_PROPERTY,
|
|
&PropertyComponentId,
|
|
sizeof(PropertyComponentId),
|
|
&ComponentId,
|
|
sizeof(ComponentId),
|
|
&BytesReturned);
|
|
|
|
// Store the component Id
|
|
if (NT_SUCCESS(Status)) {
|
|
|
|
ASSERT(BytesReturned >= sizeof(ComponentId));
|
|
|
|
this->ComponentId = new KSCOMPONENTID;
|
|
if (this->ComponentId) {
|
|
|
|
RtlCopyMemory(this->ComponentId,
|
|
&ComponentId,
|
|
sizeof(KSCOMPONENTID));
|
|
|
|
Status = lstFreeMem.AddList(this->ComponentId);
|
|
if(!NT_SUCCESS(Status)) {
|
|
delete this->ComponentId;
|
|
this->ComponentId = NULL;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
this->ComponentId = NULL;
|
|
}
|
|
|
|
Status = this->ProfileFilter(pFileObject);
|
|
exit:
|
|
if(hkeySysaudio != NULL) {
|
|
ZwClose(hkeySysaudio);
|
|
}
|
|
if(hkeyDeviceClass != NULL) {
|
|
ZwClose(hkeyDeviceClass);
|
|
}
|
|
if (pFilterNodeInstance) {
|
|
pFilterNodeInstance->Destroy();
|
|
}
|
|
return(Status);
|
|
}
|
|
|
|
NTSTATUS
|
|
CFilterNode::ProfileFilter(
|
|
PFILE_OBJECT pFileObject
|
|
)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PKSMULTIPLE_ITEM pCategories = NULL;
|
|
PKSMULTIPLE_ITEM pConnections = NULL;
|
|
PKSMULTIPLE_ITEM pNodes = NULL;
|
|
ULONG PinId;
|
|
PPIN_INFO pPinInfo;
|
|
ULONG i;
|
|
KSTOPOLOGY Topology;
|
|
|
|
RtlZeroMemory(&Topology, sizeof(Topology));
|
|
|
|
// Get the number of pins
|
|
Status = GetPinProperty(
|
|
pFileObject,
|
|
KSPROPERTY_PIN_CTYPES,
|
|
0, // doesn't matter for ctypes
|
|
sizeof(cPins),
|
|
(PVOID)&cPins);
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
Trap();
|
|
goto exit;
|
|
}
|
|
|
|
// Get the topology of the filter
|
|
Status = GetProperty(
|
|
pFileObject,
|
|
&KSPROPSETID_Topology,
|
|
KSPROPERTY_TOPOLOGY_CATEGORIES,
|
|
0,
|
|
NULL,
|
|
(PVOID*)&pCategories);
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
Trap();
|
|
goto exit;
|
|
}
|
|
|
|
if(pCategories != NULL) {
|
|
Topology.CategoriesCount = pCategories->Count;
|
|
Topology.Categories = (GUID*)(pCategories + 1);
|
|
|
|
ULONG fulType = 0;
|
|
for(i = 0; i < pCategories->Count; i++) {
|
|
GetFilterTypeFromGuid((LPGUID)&Topology.Categories[i], &fulType);
|
|
}
|
|
SetType(fulType);
|
|
}
|
|
|
|
Status = GetProperty(
|
|
pFileObject,
|
|
&KSPROPSETID_Topology,
|
|
KSPROPERTY_TOPOLOGY_NODES,
|
|
0,
|
|
NULL,
|
|
(PVOID*)&pNodes);
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
Trap();
|
|
goto exit;
|
|
}
|
|
|
|
if(pNodes != NULL) {
|
|
Status = lstFreeMem.AddList(pNodes);
|
|
if(!NT_SUCCESS(Status)) {
|
|
Trap();
|
|
delete pNodes;
|
|
goto exit;
|
|
}
|
|
Topology.TopologyNodesCount = pNodes->Count;
|
|
Topology.TopologyNodes = (GUID*)(pNodes + 1);
|
|
}
|
|
|
|
Status = GetProperty(
|
|
pFileObject,
|
|
&KSPROPSETID_Topology,
|
|
KSPROPERTY_TOPOLOGY_CONNECTIONS,
|
|
0,
|
|
NULL,
|
|
(PVOID*)&pConnections);
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
Trap();
|
|
goto exit;
|
|
}
|
|
|
|
if(pConnections != NULL) {
|
|
Topology.TopologyConnectionsCount = pConnections->Count;
|
|
Topology.TopologyConnections =
|
|
(PKSTOPOLOGY_CONNECTION)(pConnections + 1);
|
|
}
|
|
|
|
// Each pin loop
|
|
for(PinId = 0; PinId < cPins; PinId++) {
|
|
pPinInfo = new PIN_INFO(this, PinId);
|
|
if(pPinInfo == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
Trap();
|
|
goto exit;
|
|
}
|
|
Status = pPinInfo->Create(pFileObject);
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
Status = CreateTopology(this, &Topology);
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
|
|
Status = lstPinInfo.EnumerateList(CPinInfo::CreatePhysicalConnection);
|
|
if(Status == STATUS_CONTINUE) {
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
else if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
|
|
Status = CLogicalFilterNode::CreateAll(this);
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
exit:
|
|
delete pCategories;
|
|
delete pConnections;
|
|
return(Status);
|
|
}
|
|
|
|
NTSTATUS
|
|
CFilterNode::DuplicateForCapture(
|
|
)
|
|
{
|
|
PLOGICAL_FILTER_NODE pLogicalFilterNode;
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PFILTER_NODE pFilterNode = NULL;
|
|
|
|
if(GetType() & FILTER_TYPE_DUP_FOR_CAPTURE) {
|
|
|
|
FOR_EACH_LIST_ITEM(&lstLogicalFilterNode, pLogicalFilterNode) {
|
|
|
|
if(!pLogicalFilterNode->IsRenderAndCapture()) {
|
|
ASSERT(NT_SUCCESS(Status));
|
|
goto exit;
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
|
|
pFilterNode = new FILTER_NODE(GetType());
|
|
if(pFilterNode == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
Trap();
|
|
goto exit;
|
|
}
|
|
Status = pFilterNode->Create(GetDeviceInterface());
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
SetRenderOnly();
|
|
pFilterNode->SetCaptureOnly();
|
|
}
|
|
exit:
|
|
if(!NT_SUCCESS(Status)) {
|
|
Trap();
|
|
delete pFilterNode;
|
|
}
|
|
return(Status);
|
|
}
|
|
|
|
BOOL
|
|
CFilterNode::IsDeviceInterfaceMatch(
|
|
PDEVICE_NODE pDeviceNode
|
|
)
|
|
{
|
|
PWSTR pwstr, pwstrDeviceInterface;
|
|
UNICODE_STRING String1, String2;
|
|
|
|
Assert(this);
|
|
if(lstwstrDeviceInterfaceMatch.IsLstEmpty()) {
|
|
return(TRUE);
|
|
}
|
|
//
|
|
// The +4 for both the strings is to eliminate the \\.\ differences in
|
|
// user mode device interface names & kernel mode device interface names
|
|
//
|
|
pwstrDeviceInterface = pDeviceNode->GetDeviceInterface()+4;
|
|
RtlInitUnicodeString(&String2, pwstrDeviceInterface);
|
|
FOR_EACH_LIST_ITEM(&lstwstrDeviceInterfaceMatch, pwstr) {
|
|
RtlInitUnicodeString(&String1, (pwstr+4));
|
|
if (RtlEqualUnicodeString(&String1, &String2, TRUE)) {
|
|
return(TRUE);
|
|
}
|
|
} END_EACH_LIST_ITEM
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
VOID
|
|
CFilterNode::SetType(
|
|
ULONG fulType
|
|
)
|
|
{
|
|
this->fulType |= fulType;
|
|
//
|
|
// This is because of left overs (type bridge) in the registry
|
|
// that look like aliases.
|
|
//
|
|
if(this->fulType & FILTER_TYPE_TOPOLOGY) {
|
|
this->fulType = (FILTER_TYPE_AUDIO | FILTER_TYPE_TOPOLOGY);
|
|
}
|
|
GetDefaultOrder(this->fulType, &ulOrder);
|
|
}
|
|
|
|
NTSTATUS
|
|
CFilterNode::CreatePin(
|
|
PKSPIN_CONNECT pPinConnect,
|
|
ACCESS_MASK Access,
|
|
PHANDLE pHandle
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
|
|
::KeAttachProcess(this->pProcess);
|
|
Status = KsCreatePin(this->hFileHandle,
|
|
pPinConnect,
|
|
Access,
|
|
pHandle);
|
|
::KeDetachProcess();
|
|
return(Status);
|
|
}
|
|
|
|
BOOL
|
|
CFilterNode::DoesGfxMatch(
|
|
HANDLE hGfx,
|
|
PWSTR pwstrDeviceName,
|
|
ULONG GfxOrder
|
|
)
|
|
{
|
|
ULONG DeviceCount;
|
|
UNICODE_STRING usInDevice, usfnDevice;
|
|
PWSTR pwstr;
|
|
|
|
|
|
RtlInitUnicodeString(&usInDevice, (pwstrDeviceName+4));
|
|
|
|
//
|
|
// Skip if it is not a GFX
|
|
//
|
|
DPF1(90, "DoesGfxMatch:: fultype=%x", this->fulType);
|
|
if (!(this->fulType & FILTER_TYPE_GFX)) {
|
|
return(FALSE);
|
|
}
|
|
|
|
//
|
|
// If it is a valid handle value, check whether the handle matches
|
|
//
|
|
if (hGfx) {
|
|
if (this->hFileHandle != hGfx) {
|
|
return(FALSE);
|
|
}
|
|
}
|
|
//
|
|
// Skip if the order does not match
|
|
//
|
|
DPF1(90, "DoesGfxMatch:: order=%x", this->ulOrder);
|
|
if (GfxOrder != this->ulOrder) {
|
|
return(FALSE);
|
|
}
|
|
//
|
|
// Skip if the match device list is empty :: should not happen with GFX
|
|
//
|
|
if(lstwstrDeviceInterfaceMatch.IsLstEmpty()) {
|
|
ASSERT(!"GFX with no device to attach to!\n");
|
|
return(FALSE);
|
|
}
|
|
//
|
|
// Check if any of the Match device strings matches the device interface
|
|
// passed in. (In case of GFX we should have only one string though)
|
|
//
|
|
DeviceCount = 0;
|
|
FOR_EACH_LIST_ITEM(&lstwstrDeviceInterfaceMatch, pwstr) {
|
|
ASSERT(DeviceCount == 0);
|
|
RtlInitUnicodeString(&usfnDevice, (pwstr+4));
|
|
DPF1(95, "DoesGfxMatch:: new di = %s)", DbgUnicode2Sz(pwstrDeviceName));
|
|
DPF1(95, "DoesGfxMatch:: old di = %s)", DbgUnicode2Sz(pwstr));
|
|
if (RtlEqualUnicodeString(&usInDevice, &usfnDevice, TRUE)) {
|
|
DPF1(90, "Found a duplicate GFX, pFilterNode = %x", this);
|
|
return(TRUE);
|
|
}
|
|
DeviceCount++;
|
|
} END_EACH_LIST_ITEM
|
|
return (FALSE);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
#ifdef DEBUG
|
|
|
|
ULONG nFilter = 0;
|
|
|
|
VOID
|
|
DumpSysAudio(
|
|
)
|
|
{
|
|
if(gplstFilterNode != NULL) {
|
|
gplstFilterNode->Dump();
|
|
}
|
|
if(gplstDeviceNode != NULL) {
|
|
gplstDeviceNode->Dump();
|
|
}
|
|
if(gplstLogicalFilterNode != NULL &&
|
|
(ulDebugFlags & (DEBUG_FLAGS_FILTER |
|
|
DEBUG_FLAGS_DEVICE |
|
|
DEBUG_FLAGS_LOGICAL_FILTER)) ==
|
|
DEBUG_FLAGS_LOGICAL_FILTER) {
|
|
gplstLogicalFilterNode->Dump();
|
|
}
|
|
}
|
|
|
|
ENUMFUNC
|
|
CFilterNode::Dump(
|
|
)
|
|
{
|
|
Assert(this);
|
|
// .sf
|
|
if(ulDebugFlags & (DEBUG_FLAGS_FILTER | DEBUG_FLAGS_OBJECT)) {
|
|
if(ulDebugNumber == MAXULONG || ulDebugNumber == nFilter) {
|
|
if(ulDebugFlags & DEBUG_FLAGS_ADDRESS) {
|
|
dprintf("%d: %08x %s\n", nFilter, this, DumpName());
|
|
}
|
|
else {
|
|
dprintf("%d: %s\n", nFilter, DumpName());
|
|
}
|
|
// .sfv
|
|
if(ulDebugFlags & (DEBUG_FLAGS_VERBOSE | DEBUG_FLAGS_OBJECT)) {
|
|
dprintf("FN: %08x DN %08x cPins %08x ulOrder %08x\n",
|
|
this,
|
|
pDeviceNode,
|
|
cPins,
|
|
ulOrder);
|
|
dprintf(" fulType: %08x ", fulType);
|
|
DumpfulType(fulType);
|
|
dprintf("\n ulFlags: %08x ", ulFlags);
|
|
if(ulFlags & FN_FLAGS_RENDER) {
|
|
dprintf("RENDER ");
|
|
}
|
|
if(ulFlags & FN_FLAGS_NO_RENDER) {
|
|
dprintf("NO_RENDER ");
|
|
}
|
|
if(ulFlags & FN_FLAGS_CAPTURE) {
|
|
dprintf("CAPTURE ");
|
|
}
|
|
if(ulFlags & FN_FLAGS_NO_CAPTURE) {
|
|
dprintf("NO_CAPTURE ");
|
|
}
|
|
dprintf("\n");
|
|
if(pwstrDeviceInterface != NULL) {
|
|
dprintf(" %s\n", DumpDeviceInterface());
|
|
}
|
|
PWSTR pwstr;
|
|
|
|
FOR_EACH_LIST_ITEM(&lstwstrDeviceInterfaceMatch, pwstr) {
|
|
dprintf(" pwstrDevice:\n %s\n", DbgUnicode2Sz(pwstr));
|
|
} END_EACH_LIST_ITEM
|
|
|
|
dprintf(" lstLFN: ");
|
|
lstLogicalFilterNode.DumpAddress();
|
|
dprintf("\n lstConnFN:");
|
|
lstConnectedFilterNode.DumpAddress();
|
|
dprintf("\n");
|
|
}
|
|
// .sfp
|
|
if(ulDebugFlags & DEBUG_FLAGS_PIN) {
|
|
lstPinInfo.Dump();
|
|
}
|
|
// .sft
|
|
if(ulDebugFlags & DEBUG_FLAGS_TOPOLOGY) {
|
|
lstTopologyNode.Dump();
|
|
// .sftx
|
|
if(ulDebugFlags & DEBUG_FLAGS_DETAILS) {
|
|
lstTopologyConnection.Dump();
|
|
}
|
|
}
|
|
// .sfl
|
|
if(ulDebugFlags & DEBUG_FLAGS_LOGICAL_FILTER) {
|
|
lstLogicalFilterNode.Dump();
|
|
}
|
|
if(ulDebugFlags &
|
|
(DEBUG_FLAGS_VERBOSE | DEBUG_FLAGS_PIN | DEBUG_FLAGS_TOPOLOGY)) {
|
|
dprintf("\n");
|
|
}
|
|
}
|
|
nFilter++;
|
|
}
|
|
return(STATUS_CONTINUE);
|
|
}
|
|
|
|
#endif
|