undoc.cpp File Reference

#include "private.hpp"
#include <debug.h>

Include dependency graph for undoc.cpp:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
NTSTATUS NTAPI	KsoDispatchCreateWithGenericFactory (LONG Unknown, PIRP Irp)
IIrpTarget *NTAPI	KsoGetIrpTargetFromFileObject (PFILE_OBJECT FileObject)
IIrpTarget *NTAPI	KsoGetIrpTargetFromIrp (PIRP Irp)
NTSTATUS NTAPI	PcHandleEnableEventWithTable (IN PIRP Irp, IN PSUBDEVICE_DESCRIPTOR Descriptor)
NTSTATUS NTAPI	PcHandleDisableEventWithTable (IN PIRP Irp, IN PSUBDEVICE_DESCRIPTOR Descriptor)
NTSTATUS NTAPI	PcHandlePropertyWithTable (IN PIRP Irp, IN ULONG PropertySetCount, IN PKSPROPERTY_SET PropertySet, IN PSUBDEVICE_DESCRIPTOR SubDeviceDescriptor)
VOID NTAPI	PcAcquireFormatResources (LONG Unknown, LONG Unknown2, LONG Unknown3, LONG Unknown4)
NTSTATUS	PcAddToEventTable (PVOID Ptr, LONG Unknown2, ULONG Length, LONG Unknown3, LONG Unknown4, LONG Unknown5, LONG Unknown6, LONG Unknown7)
NTSTATUS NTAPI	PropertyItemDispatch (IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data)
NTSTATUS	PcAddToPropertyTable (IN PSUBDEVICE_DESCRIPTOR SubDeviceDescriptor, IN PPCPROPERTY_ITEM PropertyItem, IN ULONG bNode)
NTSTATUS	PcCaptureFormat (LONG Unknown, LONG Unknown2, LONG Unknown3, LONG Unknown4)
NTSTATUS NTAPI	PcCreateSubdeviceDescriptor (OUT SUBDEVICE_DESCRIPTOR **OutSubdeviceDescriptor, IN ULONG InterfaceCount, IN GUID *InterfaceGuids, IN ULONG IdentifierCount, IN KSIDENTIFIER *Identifier, IN ULONG FilterPropertiesCount, IN KSPROPERTY_SET *FilterProperties, IN ULONG Unknown1, IN ULONG Unknown2, IN ULONG PinPropertiesCount, IN KSPROPERTY_SET *PinProperties, IN ULONG EventSetCount, IN KSEVENT_SET *EventSet, IN PPCFILTER_DESCRIPTOR FilterDescription)
NTSTATUS NTAPI	PcValidateConnectRequest (IN PIRP Irp, IN KSPIN_FACTORY *Factory, OUT PKSPIN_CONNECT *Connect)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 11 of file undoc.cpp.

Function Documentation

KsoDispatchCreateWithGenericFactory()

NTSTATUS NTAPI KsoDispatchCreateWithGenericFactory	(	LONG	Unknown,
		PIRP	Irp
	)

Definition at line 16 of file undoc.cpp.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

KsoGetIrpTargetFromFileObject()

IIrpTarget *NTAPI KsoGetIrpTargetFromFileObject

(

PFILE_OBJECT

FileObject

)

Definition at line 26 of file undoc.cpp.

{
    PC_ASSERT(FileObject);
 
    // IrpTarget is stored in FsContext
    return (IIrpTarget*)FileObject->FsContext;
}

KsoGetIrpTargetFromIrp()

IIrpTarget *NTAPI KsoGetIrpTargetFromIrp

(

PIRP

Irp

)

Definition at line 37 of file undoc.cpp.

{
    PIO_STACK_LOCATION IoStack;
 
    // get current irp stack location
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    // IIrpTarget is stored in Context member
    return (IIrpTarget*)IoStack->FileObject->FsContext;
}

PcAcquireFormatResources()

VOID NTAPI PcAcquireFormatResources	(	LONG	Unknown,
		LONG	Unknown2,
		LONG	Unknown3,
		LONG	Unknown4
	)

Definition at line 104 of file undoc.cpp.

{
    UNIMPLEMENTED;
}

PcAddToEventTable()

NTSTATUS PcAddToEventTable	(	PVOID	Ptr,
		LONG	Unknown2,
		ULONG	Length,
		LONG	Unknown3,
		LONG	Unknown4,
		LONG	Unknown5,
		LONG	Unknown6,
		LONG	Unknown7
	)

Definition at line 114 of file undoc.cpp.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

PcAddToPropertyTable()

NTSTATUS PcAddToPropertyTable	(	IN PSUBDEVICE_DESCRIPTOR	SubDeviceDescriptor,
		IN PPCPROPERTY_ITEM	PropertyItem,
		IN ULONG	bNode
	)

Definition at line 306 of file undoc.cpp.

{
    ULONG bFound = FALSE;
    ULONG Index, PropertySetIndex, PropertySetItemIndex;
    PKSPROPERTY_SET NewPropertySet;
    PKSPROPERTY_ITEM FilterPropertyItem, NewFilterPropertyItem;
    LPGUID Guid;
    //UNICODE_STRING GuidBuffer;
 
ASSERT(PropertyItem->Set);
    //  RtlStringFromGUID(*PropertyItem->Set, &GuidBuffer);
   // DPRINT1("PcAddToPropertyTable Adding Item Set %S Id %lu Flags %lx\n", GuidBuffer.Buffer, PropertyItem->Id, PropertyItem->Flags);
 
    //DPRINT1("FilterPropertySetCount %lu\n", SubDeviceDescriptor->FilterPropertySetCount);
    // first step check if the property set is present already
    for(Index = 0; Index < SubDeviceDescriptor->FilterPropertySetCount; Index++)
    {
 
        //RtlStringFromGUID(*SubDeviceDescriptor->FilterPropertySet[Index].Set, &GuidBuffer);
        //DPRINT1("FilterProperty Set %S PropertyCount %lu\n", GuidBuffer.Buffer, SubDeviceDescriptor->FilterPropertySet[Index].PropertiesCount);
        if (IsEqualGUIDAligned(*SubDeviceDescriptor->FilterPropertySet[Index].Set, *PropertyItem->Set))
        {
            // property set is already present
            bFound = TRUE;
            PropertySetIndex = Index;
 
            // break out
            break;
        }
    }
 
    // is the property set present
    if (!bFound)
    {
        // need to allocate a property set
        NewPropertySet = (PKSPROPERTY_SET)AllocateItem(NonPagedPool, (SubDeviceDescriptor->FilterPropertySetCount + 1) * sizeof(KSPROPERTY_SET), TAG_PORTCLASS);
        if (!NewPropertySet)
        {
            // out of memory
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        // need to allocate property set guid
        Guid = (LPGUID)AllocateItem(NonPagedPool, sizeof(GUID), TAG_PORTCLASS);
        if (!Guid)
        {
            // out of memory
            FreeItem(NewPropertySet, TAG_PORTCLASS);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        // are any existing property sets
        if (SubDeviceDescriptor->FilterPropertySetCount)
        {
            // copy property sets
            RtlMoveMemory(NewPropertySet, SubDeviceDescriptor->FilterPropertySet, SubDeviceDescriptor->FilterPropertySetCount * sizeof(KSPROPERTY_SET));
 
            // release memory
            FreeItem(SubDeviceDescriptor->FilterPropertySet, TAG_PORTCLASS);
        }
 
        // store new property set descriptors
        SubDeviceDescriptor->FilterPropertySet = NewPropertySet;
 
        // store index
        PropertySetIndex = SubDeviceDescriptor->FilterPropertySetCount;
 
        // increment property set count
        SubDeviceDescriptor->FilterPropertySetCount++;
 
        // copy property guid
        RtlMoveMemory(Guid, PropertyItem->Set, sizeof(GUID));
 
        // initialize property set
        SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].Set = Guid;
        SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertiesCount = 0;
    }
 
    // as the property set has been identified, now search for duplicate property set item entries
    FilterPropertyItem = (PKSPROPERTY_ITEM)SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertyItem;
    bFound = FALSE;
 
    for(Index = 0; Index < SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertiesCount; Index++)
    {
        // now search for an equal property set item
        if (FilterPropertyItem->PropertyId == PropertyItem->Id)
        {
            // found existing property set item
            bFound = TRUE;
            PropertySetItemIndex = Index;
            break;
        }
 
        // move to next entry
        FilterPropertyItem++;
    }
 
    if (!bFound)
    {
        // need to allocate memory for new property set item
        NewFilterPropertyItem = (PKSPROPERTY_ITEM)AllocateItem(NonPagedPool, (SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertiesCount + 1) * sizeof(KSPROPERTY_ITEM), TAG_PORTCLASS);
        if (!NewFilterPropertyItem)
        {
            // out of memory
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        // are any existing property set items
        if (SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertiesCount)
        {
            // copy property item sets
            RtlMoveMemory(NewFilterPropertyItem,
                          (PVOID)SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertyItem,
                          SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertiesCount * sizeof(KSPROPERTY_ITEM));
 
            // release old descriptors
            FreeItem((PVOID)SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertyItem, TAG_PORTCLASS);
        }
 
        // store new descriptor
        SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertyItem = NewFilterPropertyItem;
 
        // store index
        PropertySetItemIndex = SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertiesCount;
 
        // increment property item set count
        SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertiesCount++;
 
        // now initialize property item
        FilterPropertyItem = (PKSPROPERTY_ITEM)&SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertyItem[PropertySetItemIndex];
        FilterPropertyItem->PropertyId = PropertyItem->Id;
        FilterPropertyItem->MinProperty = sizeof(KSPROPERTY);
        FilterPropertyItem->MinData = 0;
 
        // are any set operations supported
        if (PropertyItem->Flags & PCPROPERTY_ITEM_FLAG_SET)
        {
            // setup handler
            FilterPropertyItem->SetPropertyHandler = PropertyItemDispatch;
        }
 
        // are set operation supported
        if (PropertyItem->Flags & PCPROPERTY_ITEM_FLAG_GET)
        {
            // setup handler
            FilterPropertyItem->GetPropertyHandler = PropertyItemDispatch;
        }
 
        // are get operations supported
        if (PropertyItem->Flags & PCPROPERTY_ITEM_FLAG_GET)
        {
            // setup handler
            FilterPropertyItem->GetPropertyHandler = PropertyItemDispatch;
        }
 
        // are basic support operations supported
        if (PropertyItem->Flags & PCPROPERTY_ITEM_FLAG_BASICSUPPORT)
        {
            // setup handler
            FilterPropertyItem->SupportHandler = PropertyItemDispatch;
        }
 
        if (!bNode)
        {
            // store property item in relations
            // only store property item of filter properties / pin properties
            // because filter & pin properties do not require a specific context
            // on the other hand node properties are specifically bound to a node
 
            FilterPropertyItem->Relations = (const KSPROPERTY*)PropertyItem;
        }
    }
    else
    {
        // property set item handler already present
 
        if (bNode)
        {
            // filter & pin properties should not be exposed on a node
            ASSERT(SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertyItem[PropertySetItemIndex].Relations == NULL);
        }
        else
        {
            // node properties should not be exposed on a filter & pin
            ASSERT(SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertyItem[PropertySetItemIndex].Relations != NULL);
        }
    }
 
    // done
    return STATUS_SUCCESS;
}

Referenced by PcCreateSubdeviceDescriptor().

PcCaptureFormat()

NTSTATUS PcCaptureFormat	(	LONG	Unknown,
		LONG	Unknown2,
		LONG	Unknown3,
		LONG	Unknown4
	)

Definition at line 502 of file undoc.cpp.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

PcCreateSubdeviceDescriptor()

NTSTATUS NTAPI PcCreateSubdeviceDescriptor	(	OUT SUBDEVICE_DESCRIPTOR **	OutSubdeviceDescriptor,
		IN ULONG	InterfaceCount,
		IN GUID *	InterfaceGuids,
		IN ULONG	IdentifierCount,
		IN KSIDENTIFIER *	Identifier,
		IN ULONG	FilterPropertiesCount,
		IN KSPROPERTY_SET *	FilterProperties,
		IN ULONG	Unknown1,
		IN ULONG	Unknown2,
		IN ULONG	PinPropertiesCount,
		IN KSPROPERTY_SET *	PinProperties,
		IN ULONG	EventSetCount,
		IN KSEVENT_SET *	EventSet,
		IN PPCFILTER_DESCRIPTOR	FilterDescription
	)

Definition at line 752 of file undoc.cpp.

{
    SUBDEVICE_DESCRIPTOR * Descriptor;
    ULONG Index, SubIndex;
    NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES;
    PPCPIN_DESCRIPTOR SrcDescriptor;
    PPCNODE_DESCRIPTOR NodeDescriptor;
    PPCPROPERTY_ITEM PropertyItem;
 
    // allocate subdevice descriptor
    Descriptor = (PSUBDEVICE_DESCRIPTOR)AllocateItem(NonPagedPool, sizeof(SUBDEVICE_DESCRIPTOR), TAG_PORTCLASS);
    if (!Descriptor)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    // initialize physical / symbolic link connection list
    InitializeListHead(&Descriptor->SymbolicLinkList);
    InitializeListHead(&Descriptor->PhysicalConnectionList);
 
    //FIXME add driver category guids
    Descriptor->Interfaces = (GUID*)AllocateItem(NonPagedPool, sizeof(GUID) * InterfaceCount, TAG_PORTCLASS);
    if (!Descriptor->Interfaces)
        goto cleanup;
 
    // copy interface guids
    RtlCopyMemory(Descriptor->Interfaces, InterfaceGuids, sizeof(GUID) * InterfaceCount);
    Descriptor->InterfaceCount = InterfaceCount;
 
#if DBG
    DumpFilterDescriptor(FilterDescription);
#endif
 
    // are any property sets supported by the portcls
    if (FilterPropertiesCount)
    {
       // first allocate filter properties set
       Descriptor->FilterPropertySet = (PKSPROPERTY_SET)AllocateItem(NonPagedPool, sizeof(KSPROPERTY_SET) * FilterPropertiesCount, TAG_PORTCLASS);
       if (! Descriptor->FilterPropertySet)
           goto cleanup;
 
       // now copy all filter property sets
       Descriptor->FilterPropertySetCount = FilterPropertiesCount;
       for(Index = 0; Index < FilterPropertiesCount; Index++)
       {
           // copy property set
           RtlMoveMemory(&Descriptor->FilterPropertySet[Index], &FilterProperties[Index], sizeof(KSPROPERTY_SET));
 
           if (Descriptor->FilterPropertySet[Index].PropertiesCount)
           {
               // copy property items to make sure they are dynamically allocated
               Descriptor->FilterPropertySet[Index].PropertyItem = (PKSPROPERTY_ITEM)AllocateItem(NonPagedPool, FilterProperties[Index].PropertiesCount * sizeof(KSPROPERTY_ITEM), TAG_PORTCLASS);
               if (!Descriptor->FilterPropertySet[Index].PropertyItem)
               {
                   // no memory
                   goto cleanup;
               }
 
               // copy filter property items
               RtlMoveMemory((PVOID)Descriptor->FilterPropertySet[Index].PropertyItem, FilterProperties[Index].PropertyItem, FilterProperties[Index].PropertiesCount * sizeof(KSPROPERTY_ITEM));
           }
       }
    }
 
    // now check if the filter descriptor supports filter properties
    if (FilterDescription->AutomationTable)
    {
        // get first entry
        PropertyItem = (PPCPROPERTY_ITEM)FilterDescription->AutomationTable->Properties;
 
        // copy driver filter property sets
        for(Index = 0; Index < FilterDescription->AutomationTable->PropertyCount; Index++)
        {
            // add the property item
            Status = PcAddToPropertyTable(Descriptor, PropertyItem, FALSE);
 
            // check for success
            if (Status != STATUS_SUCCESS)
            {
                // goto cleanup
                goto cleanup;
            }
 
            // move to next entry
            PropertyItem = (PPCPROPERTY_ITEM)((ULONG_PTR)PropertyItem + FilterDescription->AutomationTable->PropertyItemSize);
        }
    }
 
    // check if the filter has pins
    if (FilterDescription->PinCount)
    {
        // allocate pin factory descriptors
        Descriptor->Factory.KsPinDescriptor = (PKSPIN_DESCRIPTOR)AllocateItem(NonPagedPool, sizeof(KSPIN_DESCRIPTOR) * FilterDescription->PinCount, TAG_PORTCLASS);
        if (!Descriptor->Factory.KsPinDescriptor)
            goto cleanup;
 
        // allocate pin instance info
        Descriptor->Factory.Instances = (PPIN_INSTANCE_INFO)AllocateItem(NonPagedPool, FilterDescription->PinCount * sizeof(PIN_INSTANCE_INFO), TAG_PORTCLASS);
        if (!Descriptor->Factory.Instances)
            goto cleanup;
 
        // initialize pin factory descriptor
        Descriptor->Factory.PinDescriptorCount = FilterDescription->PinCount;
        Descriptor->Factory.PinDescriptorSize = sizeof(KSPIN_DESCRIPTOR);
 
        // grab first entry
        SrcDescriptor = (PPCPIN_DESCRIPTOR)FilterDescription->Pins;
 
        // copy pin factories
        for(Index = 0; Index < FilterDescription->PinCount; Index++)
        {
            // copy pin descriptor
            RtlMoveMemory(&Descriptor->Factory.KsPinDescriptor[Index], &SrcDescriptor->KsPinDescriptor, sizeof(KSPIN_DESCRIPTOR));
 
            // initialize pin factory instance data
            Descriptor->Factory.Instances[Index].CurrentPinInstanceCount = 0;
            Descriptor->Factory.Instances[Index].MaxFilterInstanceCount = SrcDescriptor->MaxFilterInstanceCount;
            Descriptor->Factory.Instances[Index].MaxGlobalInstanceCount = SrcDescriptor->MaxGlobalInstanceCount;
            Descriptor->Factory.Instances[Index].MinFilterInstanceCount = SrcDescriptor->MinFilterInstanceCount;
 
            // check if the descriptor has an automation table
            if (SrcDescriptor->AutomationTable)
            {
                // it has, grab first entry
                PropertyItem = (PPCPROPERTY_ITEM)SrcDescriptor->AutomationTable->Properties;
 
                // now add all supported property items
                for(SubIndex = 0; SubIndex < SrcDescriptor->AutomationTable->PropertyCount; SubIndex++)
                {
                    // add the property item to the table
                    Status = PcAddToPropertyTable(Descriptor, PropertyItem, FALSE);
 
                    // check for success
                    if (Status != STATUS_SUCCESS)
                    {
                        // goto cleanup
                        goto cleanup;
                    }
 
                    // move to next entry
                    PropertyItem = (PPCPROPERTY_ITEM)((ULONG_PTR)PropertyItem + SrcDescriptor->AutomationTable->PropertyItemSize);
                }
            }
 
            // move to next entry
            SrcDescriptor = (PPCPIN_DESCRIPTOR)((ULONG_PTR)SrcDescriptor + FilterDescription->PinSize);
        }
    }
 
    // allocate topology descriptor
    Descriptor->Topology = (PKSTOPOLOGY)AllocateItem(NonPagedPool, sizeof(KSTOPOLOGY), TAG_PORTCLASS);
    if (!Descriptor->Topology)
        goto cleanup;
 
    // are there any connections
    if (FilterDescription->ConnectionCount)
    {
        // allocate connection descriptor
        Descriptor->Topology->TopologyConnections = (PKSTOPOLOGY_CONNECTION)AllocateItem(NonPagedPool, sizeof(KSTOPOLOGY_CONNECTION) * FilterDescription->ConnectionCount, TAG_PORTCLASS);
        if (!Descriptor->Topology->TopologyConnections)
            goto cleanup;
 
        // copy connection descriptor
        RtlMoveMemory((PVOID)Descriptor->Topology->TopologyConnections, FilterDescription->Connections, FilterDescription->ConnectionCount * sizeof(PCCONNECTION_DESCRIPTOR));
 
        // store connection count
        Descriptor->Topology->TopologyConnectionsCount = FilterDescription->ConnectionCount;
    }
 
    // does the filter have nodes
    if (FilterDescription->NodeCount)
    {
        // allocate topology node types array
        Descriptor->Topology->TopologyNodes = (const GUID *)AllocateItem(NonPagedPool, sizeof(GUID) * FilterDescription->NodeCount, TAG_PORTCLASS);
        if (!Descriptor->Topology->TopologyNodes)
            goto cleanup;
 
        // allocate topology node names array
        Descriptor->Topology->TopologyNodesNames = (const GUID *)AllocateItem(NonPagedPool, sizeof(GUID) * FilterDescription->NodeCount, TAG_PORTCLASS);
        if (!Descriptor->Topology->TopologyNodesNames)
            goto cleanup;
 
        // grab first entry
       NodeDescriptor = (PPCNODE_DESCRIPTOR)FilterDescription->Nodes;
 
       // iterate all nodes and copy node types / names and node properties
        for(Index = 0; Index < FilterDescription->NodeCount; Index++)
        {
            // does it have a type
            if (NodeDescriptor->Type)
            {
                // copy node type
                RtlMoveMemory((PVOID)&Descriptor->Topology->TopologyNodes[Index], NodeDescriptor->Type, sizeof(GUID));
            }
 
            // does it have a node name
            if (NodeDescriptor->Name)
            {
                // copy node name
                RtlMoveMemory((PVOID)&Descriptor->Topology->TopologyNodesNames[Index], NodeDescriptor->Name, sizeof(GUID));
            }
 
            // check if has an automation table
            if (NodeDescriptor->AutomationTable)
            {
                // grab first entry
                PropertyItem = (PPCPROPERTY_ITEM)NodeDescriptor->AutomationTable->Properties;
 
                // copy all node properties into the global property set
                for(SubIndex = 0; SubIndex < NodeDescriptor->AutomationTable->PropertyCount; SubIndex++)
                {
                    // add to property set
                    Status = PcAddToPropertyTable(Descriptor, PropertyItem, TRUE);
 
                    // check for success
                    if (Status != STATUS_SUCCESS)
                    {
                        // failed
                        goto cleanup;
                    }
 
                    // move to next property item
                    PropertyItem = (PPCPROPERTY_ITEM)((ULONG_PTR)PropertyItem + NodeDescriptor->AutomationTable->PropertyItemSize);
                }
            }
 
            // move to next descriptor
            NodeDescriptor = (PPCNODE_DESCRIPTOR)((ULONG_PTR)NodeDescriptor + FilterDescription->NodeSize);
        }
 
        // now store the topology node count
        Descriptor->Topology->TopologyNodesCount = FilterDescription->NodeCount;
    }
 
    // store descriptor
    Descriptor->DeviceDescriptor = FilterDescription;
 
    // store result
    *OutSubdeviceDescriptor = Descriptor;
    // done
    return STATUS_SUCCESS;
 
cleanup:
    if (Descriptor)
    {
        if (Descriptor->Interfaces)
            FreeItem(Descriptor->Interfaces, TAG_PORTCLASS);
 
        if (Descriptor->Factory.KsPinDescriptor)
            FreeItem(Descriptor->Factory.KsPinDescriptor, TAG_PORTCLASS);
 
        FreeItem(Descriptor, TAG_PORTCLASS);
    }
    return Status;
}

PcHandleDisableEventWithTable()

NTSTATUS NTAPI PcHandleDisableEventWithTable	(	IN PIRP	Irp,
		IN PSUBDEVICE_DESCRIPTOR	Descriptor
	)

Definition at line 64 of file undoc.cpp.

{
    // store descriptor
    KSEVENT_ITEM_IRP_STORAGE(Irp) = (PKSEVENT_ITEM)Descriptor;
 
    // FIXME seh probing
 
    return KsDisableEvent(Irp, Descriptor->EventList, KSEVENTS_SPINLOCK, (PVOID)Descriptor->EventListLock);
}

PcHandleEnableEventWithTable()

NTSTATUS NTAPI PcHandleEnableEventWithTable	(	IN PIRP	Irp,
		IN PSUBDEVICE_DESCRIPTOR	Descriptor
	)

Definition at line 51 of file undoc.cpp.

{
    // store descriptor
    KSEVENT_ITEM_IRP_STORAGE(Irp) = (PKSEVENT_ITEM)Descriptor;
 
    // FIXME seh probing
    return KsEnableEvent(Irp, Descriptor->EventSetCount, Descriptor->EventSet, NULL, KSEVENTS_NONE, NULL);
}

PcHandlePropertyWithTable()

NTSTATUS NTAPI PcHandlePropertyWithTable	(	IN PIRP	Irp,
		IN ULONG	PropertySetCount,
		IN PKSPROPERTY_SET	PropertySet,
		IN PSUBDEVICE_DESCRIPTOR	SubDeviceDescriptor
	)

Definition at line 78 of file undoc.cpp.

{
    PIO_STACK_LOCATION IoStack;
 
    // get current irp stack location
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(KSPROPERTY))
    {
        // certainly an invalid request
        return STATUS_INVALID_PARAMETER;
    }
 
    // store device descriptor
    KSPROPERTY_ITEM_IRP_STORAGE(Irp) = (PKSPROPERTY_ITEM)SubDeviceDescriptor;
 
    // then try KsPropertyHandler
    return KsPropertyHandler(Irp, PropertySetCount, PropertySet);
}

Referenced by CPortPinWavePci::HandleKsProperty().

PcValidateConnectRequest()

NTSTATUS NTAPI PcValidateConnectRequest	(	IN PIRP	Irp,
		IN KSPIN_FACTORY *	Factory,
		OUT PKSPIN_CONNECT *	Connect
	)

Definition at line 1022 of file undoc.cpp.

{
    return KsValidateConnectRequest(Irp, Factory->PinDescriptorCount, Factory->KsPinDescriptor, Connect);
}

PropertyItemDispatch()

NTSTATUS NTAPI PropertyItemDispatch	(	IN PIRP	Irp,
		IN PKSIDENTIFIER	Request,
		IN OUT PVOID	Data
	)

Definition at line 130 of file undoc.cpp.

{
    PPCPROPERTY_REQUEST PropertyRequest;
    PSUBDEVICE_DESCRIPTOR Descriptor;
    PKSPROPERTY Property;
    PPCNODE_DESCRIPTOR NodeDescriptor;
    PKSNODEPROPERTY NodeProperty;
    PKSPROPERTY_SET PropertySet;
    PPCPROPERTY_ITEM PropertyItem;
    PPCAUTOMATION_TABLE NodeAutomation;
    PIO_STACK_LOCATION IoStack;
    ULONG InstanceSize, ValueSize, Index;
    PVOID Instance;
    NTSTATUS Status;
 
    // allocate a property request
    PropertyRequest = (PPCPROPERTY_REQUEST)AllocateItem(NonPagedPool, sizeof(PCPROPERTY_REQUEST), TAG_PORTCLASS);
    if (!PropertyRequest)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    // grab device descriptor
    Descriptor = (PSUBDEVICE_DESCRIPTOR)KSPROPERTY_ITEM_IRP_STORAGE(Irp);
 
    // get current irp stack
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    // get input property request
    Property = (PKSPROPERTY)Request;
 
    // get property set
    PropertySet = (PKSPROPERTY_SET)KSPROPERTY_SET_IRP_STORAGE(Irp);
 
    // sanity check
    PC_ASSERT(Descriptor);
    PC_ASSERT(Descriptor->UnknownMiniport);
 
    // get instance / value size
    InstanceSize = IoStack->Parameters.DeviceIoControl.InputBufferLength;
    Instance = Request;
    ValueSize = IoStack->Parameters.DeviceIoControl.OutputBufferLength;
 
     // initialize property request
     PropertyRequest->MajorTarget = Descriptor->UnknownMiniport;
     PropertyRequest->MinorTarget = Descriptor->UnknownStream;
     PropertyRequest->Irp = Irp;
     PropertyRequest->Verb = Property->Flags;
 
    // check if this is filter / pin property request
    if (!(Property->Flags & KSPROPERTY_TYPE_TOPOLOGY))
    {
        // adjust input buffer size
        InstanceSize -= sizeof(KSPROPERTY);
        Instance = (PVOID)((ULONG_PTR)Instance + sizeof(KSPROPERTY));
 
        // filter / pin property request dont use node field
        PropertyRequest->Node = MAXULONG;
    }
    else if (InstanceSize >= sizeof(KSNODEPROPERTY))
    {
        // request is for a node
        InstanceSize -= sizeof(KSNODEPROPERTY);
        Instance = (PVOID)((ULONG_PTR)Instance + sizeof(KSNODEPROPERTY));
 
        // cast node property request
        NodeProperty = (PKSNODEPROPERTY)Request;
 
        // store node id
        PropertyRequest->Node = NodeProperty->NodeId;
    }
    else
    {
        // invalid buffer size
        FreeItem(PropertyRequest, TAG_PORTCLASS);
        return STATUS_INVALID_BUFFER_SIZE;
    }
 
    // store instance size
    PropertyRequest->InstanceSize = InstanceSize;
    PropertyRequest->Instance = (InstanceSize != 0 ? Instance : NULL);
 
    // store value size
    PropertyRequest->ValueSize = ValueSize;
    PropertyRequest->Value = Data;
 
    // now scan the property set for the attached property set item stored in Relations member
    if (PropertySet)
    {
        // sanity check
        PC_ASSERT(IsEqualGUIDAligned(Property->Set, *PropertySet->Set));
 
        for(Index = 0; Index < PropertySet->PropertiesCount; Index++)
        {
            // check if they got the same property id
            if (PropertySet->PropertyItem[Index].PropertyId == Property->Id)
            {
                // found item
                PropertyRequest->PropertyItem = (const PCPROPERTY_ITEM*)PropertySet->PropertyItem[Index].Relations;
 
                // done
                break;
            }
        }
    }
 
    // check if there has been a property set item attached
    if (!PropertyRequest->PropertyItem)
    {
        // is topology node id valid
        if (PropertyRequest->Node < Descriptor->DeviceDescriptor->NodeCount)
        {
            // get node descriptor
            NodeDescriptor = (PPCNODE_DESCRIPTOR) ((ULONG_PTR)Descriptor->DeviceDescriptor->Nodes + PropertyRequest->Node * Descriptor->DeviceDescriptor->NodeSize);
 
            // get node automation table
            NodeAutomation = (PPCAUTOMATION_TABLE)NodeDescriptor->AutomationTable;
 
            // has it got a automation table
            if (NodeAutomation)
            {
                // now scan the properties and check if it supports this request
                PropertyItem = (PPCPROPERTY_ITEM)NodeAutomation->Properties;
                for(Index = 0; Index < NodeAutomation->PropertyCount; Index++)
                {
                    // are they same property
                    if (IsEqualGUIDAligned(*PropertyItem->Set, Property->Set))
                    {
                        if (PropertyItem->Id == Property->Id)
                        {
                            // found match
                            PropertyRequest->PropertyItem = PropertyItem;
                            DPRINT("Using property item %p\n", PropertyItem);
                            // done
                            break;
                        }
                    }
 
                    // move to next property item
                    PropertyItem = (PPCPROPERTY_ITEM)((ULONG_PTR)PropertyItem + NodeAutomation->PropertyItemSize);
                }
            }
        }
    }
 
    if (PropertyRequest->PropertyItem && PropertyRequest->PropertyItem->Handler)
    {
        // now call the handler
        UNICODE_STRING GuidBuffer;
        RtlStringFromGUID(Property->Set, &GuidBuffer);
        DPRINT("Calling Node %lu MajorTarget %p MinorTarget %p PropertySet %S PropertyId %lu PropertyFlags %lx InstanceSize %lu ValueSize %lu Handler %p PropertyRequest %p PropertyItemFlags %lx PropertyItemId %lu\n",
                PropertyRequest->Node, PropertyRequest->MajorTarget, PropertyRequest->MinorTarget, GuidBuffer.Buffer, Property->Id, Property->Flags, PropertyRequest->InstanceSize, PropertyRequest->ValueSize,
                PropertyRequest->PropertyItem->Handler, PropertyRequest, PropertyRequest->PropertyItem->Flags, PropertyRequest->PropertyItem->Id);
        RtlFreeUnicodeString(&GuidBuffer);
        Status = PropertyRequest->PropertyItem->Handler(PropertyRequest);
        DPRINT("Status %lx ValueSize %lu Information %lu\n", Status, PropertyRequest->ValueSize, Irp->IoStatus.Information);
        Irp->IoStatus.Information = PropertyRequest->ValueSize;
 
        if (Status != STATUS_PENDING)
        {
            // free property request
            FreeItem(PropertyRequest, TAG_PORTCLASS);
        }
    }
    else
    {
        FreeItem(PropertyRequest, TAG_PORTCLASS);
        Status = STATUS_NOT_FOUND;
    }
 
    /* done */
    return Status;
}

Referenced by PcAddToPropertyTable().