ksfunc.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	TAG_KSDEVICE   'DESK'
#define	TAG_KSOBJECT_TAG   'HOSK'

Functions
VOID	CompleteRequest (PIRP Irp, CCHAR PriorityBoost)
NTSTATUS NTAPI	KspCreateObjectType (IN HANDLE ParentHandle, IN LPWSTR ObjectType, PVOID CreateParameters, UINT CreateParametersSize, IN ACCESS_MASK DesiredAccess, OUT PHANDLE NodeHandle)
NTSTATUS NTAPI	KspCreateFilterFactory (IN PDEVICE_OBJECT DeviceObject, IN const KSFILTER_DESCRIPTOR *Descriptor, IN PWSTR RefString OPTIONAL, IN PSECURITY_DESCRIPTOR SecurityDescriptor OPTIONAL, IN ULONG CreateItemFlags, IN PFNKSFILTERFACTORYPOWER SleepCallback OPTIONAL, IN PFNKSFILTERFACTORYPOWER WakeCallback OPTIONAL, OUT PKSFILTERFACTORY *FilterFactory OPTIONAL)
NTSTATUS NTAPI	IKsDevice_Create (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	IKsDevice_Pnp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	IKsDevice_Power (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	KspCreateFilter (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN IKsFilterFactory *iface)
NTSTATUS	KspSetDeviceInterfacesState (IN PLIST_ENTRY ListHead, IN BOOL Enable)
NTSTATUS	KspFreeDeviceInterfaces (IN PLIST_ENTRY ListHead)
NTSTATUS	KspRegisterDeviceInterfaces (IN PDEVICE_OBJECT PhysicalDeviceObject, IN ULONG CategoriesCount, IN GUID const *Categories, IN PUNICODE_STRING ReferenceString, OUT PLIST_ENTRY SymbolicLinkList)
PVOID	AllocateItem (IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
VOID	FreeItem (IN PVOID Item)
KSDDKAPI NTSTATUS NTAPI	KspPinPropertyHandler (IN PIRP Irp, IN PKSPROPERTY Property, IN OUT PVOID Data, IN ULONG DescriptorsCount, IN const KSPIN_DESCRIPTOR *Descriptors, IN ULONG DescriptorSize)
NTSTATUS	FindMatchingCreateItem (PLIST_ENTRY ListHead, PUNICODE_STRING String, OUT PCREATE_ITEM_ENTRY *OutCreateItem)
NTSTATUS	KspCopyCreateRequest (IN PIRP Irp, IN LPWSTR ObjectClass, IN OUT PULONG Size, OUT PVOID *Result)
NTSTATUS	KspCreatePin (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PKSDEVICE KsDevice, IN IKsFilterFactory *FilterFactory, IN IKsFilter *Filter, IN PKSPIN_CONNECT Connect, IN KSPIN_DESCRIPTOR_EX *Descriptor)
NTSTATUS	KspAddCreateItemToList (OUT PLIST_ENTRY ListHead, IN ULONG ItemsCount, IN PKSOBJECT_CREATE_ITEM ItemsList)
VOID	KspFreeCreateItems (IN PLIST_ENTRY ListHead)
NTSTATUS	KspPropertyHandler (IN PIRP Irp, IN ULONG PropertySetsCount, IN const KSPROPERTY_SET *PropertySet, IN PFNKSALLOCATOR Allocator OPTIONAL, IN ULONG PropertyItemSize OPTIONAL)
NTSTATUS NTAPI	IKsFilterFactory_Create (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	KspSetFilterFactoriesState (IN PKSIDEVICE_HEADER DeviceHeader, IN BOOLEAN NewState)
NTSTATUS NTAPI	KspMethodHandlerWithAllocator (IN PIRP Irp, IN ULONG MethodSetsCount, IN const KSMETHOD_SET *MethodSet, IN PFNKSALLOCATOR Allocator OPTIONAL, IN ULONG MethodItemSize OPTIONAL)
VOID	IKsFilter_AddPin (PKSFILTER Filter, PKSPIN Pin)
VOID	IKsFilter_RemovePin (PKSFILTER Filter, PKSPIN Pin)
NTSTATUS	KspEnableEvent (IN PIRP Irp, IN ULONG EventSetsCount, IN const KSEVENT_SET *EventSet, IN OUT PLIST_ENTRY EventsList OPTIONAL, IN KSEVENTS_LOCKTYPE EventsFlags OPTIONAL, IN PVOID EventsLock OPTIONAL, IN PFNKSALLOCATOR Allocator OPTIONAL, IN ULONG EventItemSize OPTIONAL)
NTSTATUS	KspValidateConnectRequest (IN PIRP Irp, IN ULONG DescriptorsCount, IN PVOID Descriptors, IN ULONG DescriptorSize, OUT PKSPIN_CONNECT *Connect)
NTSTATUS	KspReadMediaCategory (IN LPGUID Category, PKEY_VALUE_PARTIAL_INFORMATION *OutInformation)

Macro Definition Documentation

TAG_KSDEVICE

#define TAG_KSDEVICE   'DESK'

Definition at line 3 of file ksfunc.h.

TAG_KSOBJECT_TAG

#define TAG_KSOBJECT_TAG   'HOSK'

Definition at line 4 of file ksfunc.h.

Function Documentation

AllocateItem()

PVOID AllocateItem	(	IN POOL_TYPE	PoolType,
		IN SIZE_T	NumberOfBytes
	)

Definition at line 29 of file misc.c.

{
    return ExAllocatePoolZero(PoolType, NumberOfBytes, TAG_KS);
}

Referenced by _KsEdit(), Alloc(), AllocateInterfaceDescriptorsArray(), AllocEventData(), ComputeCompatibleFormat(), DispatchCreateSysAudio(), DispatchCreateSysAudioPin(), EventCallback(), FDO_CreateChildPdo(), FDO_DeviceRelations(), GetConnectRequest(), CPortPinWaveRT::HandleKsProperty(), HDA_FDOQueryBusRelations(), HDA_InitCodec(), HDA_PDOHandleQueryDeviceText(), HDA_PDOQueryBusInformation(), HDA_PDOQueryId(), IKsDevice_PnpStartDevice(), IKsFilter_CopyFilterDescriptor(), IKsFilter_CreateDescriptors(), IKsFilterFactory_fnInitialize(), InsertAudioDevice(), InstantiatePins(), KopAddDevice(), KopDispatchCreate(), KsAddItemToObjectBag(), KsAllocateDefaultClockEx(), KsAllocateDeviceHeader(), KsAllocateExtraData(), KsAllocateObjectBag(), KsAllocateObjectCreateItem(), KsAllocateObjectHeader(), KsCacheMedium(), KsCreateBusEnumObject(), KsCreateDefaultAllocatorEx(), KsCreateDefaultClock(), KsFilterFactoryUpdateCacheData(), KsGetBusEnumIdentifier(), KsGetImageNameAndResourceId(), KsInitializeDevice(), KsLoadResource(), KsMapModuleName(), KsMergeAutomationTables(), KspAddCreateItemToList(), KspBusQueryReferenceString(), KspCreateDeviceAssociation(), KspCreateDeviceReference(), KspCreateFilter(), KspCreateFilterFactory(), KspCreateObjectType(), KspCreatePDO(), KspCreatePin(), KspEnableEvent(), KspEnumerateBusRegistryKeys(), KspMergePropertySet(), KspPropertyHandler(), KspQueryBusInformation(), KspQueryBusRelations(), KspQueryId(), KspReadMediaCategory(), KspRegisterDeviceInterfaces(), KsProbeStreamIrp(), KspStartBusDevice(), KsRegisterWorker(), KsServiceBusEnumPnpRequest(), KsSetInformationFile(), KsStreamPointerClone(), NewDispatchObject(), PcAddAdapterDevice(), PcAddToPropertyTable(), PcCreateItemDispatch(), PcCreateSubdeviceDescriptor(), PcNewResourceList(), PcNewResourceSublist(), PcRegisterIoTimeout(), PcRegisterSubdevice(), PortClsPower(), PropertyItemDispatch(), QueryKeyValue(), RegisterConnection(), SysAudioAllocateDeviceHeader(), USBCCG_InitIdsWithInterfaceDescriptor(), USBCCGP_BuildConfigurationDescriptor(), USBCCGP_EnumWithAssociationDescriptor(), USBCCGP_EnumWithAudioLegacy(), USBCCGP_GetDescriptor(), USBCCGP_GetStringDescriptor(), USBCCGP_InitFunctionDescriptor(), USBCCGP_LegacyEnum(), USBCCGP_PdoAppendInterfaceNumber(), USBCCGP_PdoHandleDeviceRelations(), USBCCGP_PdoHandleQueryDeviceText(), USBCCGP_PdoHandleQueryId(), USBCCGP_PDOSelectConfiguration(), USBCCGP_ScanConfigurationDescriptor(), USBCCGP_SelectConfiguration(), USBCCGP_SelectInterface(), USBSTOR_AllocateIrpContext(), USBSTOR_FdoHandleDeviceRelations(), USBSTOR_GetDescriptor(), USBSTOR_GetEndpointStatus(), USBSTOR_PdoHandleDeviceRelations(), USBSTOR_PdoHandleQueryCompatibleId(), USBSTOR_PdoHandleQueryDeviceId(), USBSTOR_PdoHandleQueryDeviceText(), USBSTOR_PdoHandleQueryHardwareId(), USBSTOR_PdoHandleQueryInstanceId(), USBSTOR_ResetPipeWithHandle(), USBSTOR_SelectConfigurationAndInterface(), USBSTOR_SendCapacity(), USBSTOR_SendModeSense(), WdmAudControlOpenMixer(), WdmAudOpenSysaudio(), WdmAudOpenSysAudioDeviceInterfaces(), WdmAudOpenSysAudioDevices(), and WdmAudReadWrite().

CompleteRequest()

VOID CompleteRequest	(	PIRP	Irp,
		CCHAR	PriorityBoost
	)

Definition at line 17 of file misc.c.

{
    DPRINT("Completing IRP %p Status %x\n", Irp, Irp->IoStatus.Status);
 
    ASSERT(Irp->IoStatus.Status != STATUS_PENDING);
 
    IoCompleteRequest(Irp, PriorityBoost);
}

FindMatchingCreateItem()

NTSTATUS FindMatchingCreateItem	(	PLIST_ENTRY	ListHead,
		PUNICODE_STRING	String,
		OUT PCREATE_ITEM_ENTRY *	OutCreateItem
	)

Definition at line 1783 of file irp.c.

{
    PLIST_ENTRY Entry;
    PCREATE_ITEM_ENTRY CreateItemEntry;
    UNICODE_STRING RefString;
    LPWSTR pStr;
    ULONG Count;
 
    /* Copy the input string */
    RefString = *String;
 
    /* Check if the string starts with a backslash */
    if (String->Buffer[0] == L'\\')
    {
        /* Skip backslash */
        RefString.Buffer++;
        RefString.Length -= sizeof(WCHAR);
    }
    else
    {
        /* get terminator */
        pStr = String->Buffer;
        Count = String->Length / sizeof(WCHAR);
        while ((Count > 0) && (*pStr != L'\\'))
        {
            pStr++;
            Count--;
        }
 
        /* sanity check */
        ASSERT(Count != 0);
 
        // request is for pin / node / allocator
        RefString.Length = (USHORT)((PCHAR)pStr - (PCHAR)String->Buffer);
    }
 
    /* point to first entry */
    Entry = ListHead->Flink;
 
    /* loop all device items */
    while (Entry != ListHead)
    {
        /* get create item entry */
        CreateItemEntry = (PCREATE_ITEM_ENTRY)CONTAINING_RECORD(Entry,
                                                                CREATE_ITEM_ENTRY,
                                                                Entry);
 
        ASSERT(CreateItemEntry->CreateItem);
 
        if(CreateItemEntry->CreateItem->Flags & KSCREATE_ITEM_WILDCARD)
        {
            /* create item is default */
            *OutCreateItem = CreateItemEntry;
            return STATUS_SUCCESS;
        }
 
        if (!CreateItemEntry->CreateItem->Create)
        {
            /* skip free create item */
            Entry = Entry->Flink;
            continue;
        }
 
        DPRINT("CreateItem %S Length %u Request %wZ %u\n",
               CreateItemEntry->CreateItem->ObjectClass.Buffer,
               CreateItemEntry->CreateItem->ObjectClass.Length,
               &RefString,
               RefString.Length);
 
        if (CreateItemEntry->CreateItem->ObjectClass.Length > RefString.Length)
        {
            /* create item doesnt match in length */
            Entry = Entry->Flink;
            continue;
        }
 
         /* now check if the object class is the same */
        if (!RtlCompareUnicodeString(&CreateItemEntry->CreateItem->ObjectClass,
                                     &RefString,
                                     TRUE))
        {
            /* found matching create item */
            *OutCreateItem = CreateItemEntry;
            return STATUS_SUCCESS;
        }
        /* iterate to next */
        Entry = Entry->Flink;
    }
 
    return STATUS_NOT_FOUND;
}

Referenced by IKsDevice_Create(), and KspCreate().

FreeItem()

VOID FreeItem

(

IN PVOID

Item

)

Definition at line 37 of file misc.c.

{
    ExFreePoolWithTag(Item, TAG_KS);
}

Referenced by _KsEdit(), AllocEventData(), ComputeCompatibleFormat(), Dispatch_fnClose(), DispatchCreateSysAudioPin(), Enum(), Free(), FreeEventData(), CPortPinWaveRT::HandleKsProperty(), HDA_FDORemoveDevice(), HDA_InitCodec(), IKsAllocator_fnRelease(), IKsDevice_PnpPostStart(), IKsDevice_PnpStartDevice(), IKsFilter_CopyFilterDescriptor(), IKsFilter_CreateDescriptors(), IKsFilter_fnRelease(), IKsFilterFactory_fnRelease(), IKsPin_fnRelease(), InsertAudioDevice(), InstantiatePins(), IoCompletion(), KopAddDevice(), KopDispatchClose(), KopDispatchCreate(), KsAllocateExtraData(), KsAllocateObjectCreateItem(), KsAllocateObjectHeader(), KsCacheMedium(), KsCreateBusEnumObject(), KsCreateDefaultAllocatorEx(), KsCreateDefaultClock(), KsDiscardEvent(), KsDispatchSetSecurity(), KsFilterFactoryUpdateCacheData(), KsFreeDefaultClock(), KsFreeDeviceHeader(), KsFreeObjectBag(), KsFreeObjectHeader(), KsGetImageNameAndResourceId(), KsLoadResource(), KsMapModuleName(), KsMergeAutomationTables(), KspCreateDeviceAssociation(), KspCreateDeviceReference(), KspCreateFilter(), KspCreateObjectType(), KspCreatePin(), KspEnumerateBusRegistryKeys(), KspFreeCreateItems(), KspFreeDeviceInterfaces(), KspMergePropertySet(), KspPinPropertyHandler(), KspReadMediaCategory(), KspRegisterDeviceAssociation(), KspRegisterDeviceInterfaces(), KspRemoveDeviceAssociations(), KspValidateConnectRequest(), KsRegisterFilterWithNoKSPins(), KsRemoveItemFromObjectBag(), KsServiceBusEnumPnpRequest(), KsSetInformationFile(), KsStreamPointerClone(), KsStreamPointerDelete(), KsTopologyPropertyHandler(), KsUnregisterWorker(), KsValidateAllocatorCreateRequest(), KsValidateClockCreateRequest(), KsValidateTopologyNodeCreateRequest(), NewDispatchObject(), PcAddAdapterDevice(), PcAddToPropertyTable(), PcCompletePendingPropertyRequest(), PcCreateItemDispatch(), PcCreatePinDispatch(), PcCreateSubdeviceDescriptor(), PcNewResourceList(), PcRegisterIoTimeout(), PcUnregisterIoTimeout(), PDO_HandleInternalDeviceControl(), Pin_fnClose(), PropertyItemDispatch(), PwrCompletionFunction(), QueryKeyValue(), RegisterConnection(), USBCCGP_BuildConfigurationDescriptor(), USBCCGP_GetDescriptor(), USBCCGP_GetDescriptors(), USBCCGP_GetStringDescriptor(), USBCCGP_PDOSelectConfiguration(), USBCCGP_SelectInterface(), USBSTOR_AllocateIrpContext(), USBSTOR_CSWCompletionRoutine(), USBSTOR_GetDescriptor(), USBSTOR_GetDescriptors(), USBSTOR_GetEndpointStatus(), USBSTOR_HandleTransferError(), USBSTOR_ResetPipeWithHandle(), USBSTOR_SelectConfigurationAndInterface(), USBSTOR_SendModeSense(), USBSTOR_SendRequest(), WdmAudCleanup(), WdmAudControlOpenMixer(), WdmAudGetDeviceInterface(), WdmAudGetMixerEvent(), WdmAudOpenSysAudioDevices(), WdmAudReadWrite(), and CResourceList::~CResourceList().

IKsDevice_Create()

NTSTATUS NTAPI IKsDevice_Create	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 566 of file device.c.

{
    PCREATE_ITEM_ENTRY CreateItemEntry;
    PIO_STACK_LOCATION IoStack;
    PDEVICE_EXTENSION DeviceExtension;
    PKSIDEVICE_HEADER DeviceHeader;
    PKSIOBJECT_HEADER ObjectHeader;
    NTSTATUS Status;
 
    DPRINT("IKsDevice_Create\n");
    /* get current stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    /* get device extension */
    DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
    /* get device header */
    DeviceHeader = DeviceExtension->DeviceHeader;
 
    if (IoStack->FileObject->FileName.Buffer == NULL)
    {
        // ReactOS PnPMgr still sucks
        ASSERT(IoStack->FileObject->FileName.Length == 0);
        Irp->IoStatus.Status = STATUS_SUCCESS;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        DPRINT1("ReactOS PnP hack\n");
        return STATUS_SUCCESS;
    }
 
    /* acquire list lock */
    IKsDevice_fnAcquireDevice((IKsDevice*)&DeviceHeader->BasicHeader.OuterUnknown);
 
    /* sanity check */
    ASSERT(IoStack->FileObject);
 
    /* check if the request is relative */
    if (IoStack->FileObject->RelatedFileObject != NULL)
    {
        /* request is to instantiate a pin / node / clock / allocator */
        ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->RelatedFileObject->FsContext2;
 
        /* sanity check */
        ASSERT(ObjectHeader);
 
        /* find a matching a create item */
        Status = FindMatchingCreateItem(&ObjectHeader->ItemList,
                                        &IoStack->FileObject->FileName,
                                        &CreateItemEntry);
    }
    else
    {
        /* request to create a filter */
        Status = FindMatchingCreateItem(&DeviceHeader->ItemList,
                                        &IoStack->FileObject->FileName,
                                        &CreateItemEntry);
    }
 
    if (NT_SUCCESS(Status))
    {
        /* set object create item */
        KSCREATE_ITEM_IRP_STORAGE(Irp) = CreateItemEntry->CreateItem;
 
        /* call create function */
        Status = CreateItemEntry->CreateItem->Create(DeviceObject, Irp);
 
        if (NT_SUCCESS(Status))
        {
            /* increment create item reference count */
            InterlockedIncrement(&CreateItemEntry->ReferenceCount);
        }
    }
 
    /* release list lock */
    IKsDevice_fnReleaseDevice((IKsDevice*)&DeviceHeader->BasicHeader.OuterUnknown);
 
    /* done */
    return Status;
 
 
}

Referenced by KsDispatchIrp(), and KsInitializeDriver().

IKsDevice_Pnp()

NTSTATUS NTAPI IKsDevice_Pnp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 409 of file device.c.

{
    PIO_STACK_LOCATION IoStack;
    PDEVICE_EXTENSION DeviceExtension;
    PKSIDEVICE_HEADER DeviceHeader;
    PKSDEVICE_DISPATCH Dispatch = NULL;
    NTSTATUS Status;
 
    /* get current stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* get device extension */
    DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
    /* get device header */
    DeviceHeader = DeviceExtension->DeviceHeader;
 
    /* do we have a device descriptor */
    if (DeviceHeader->KsDevice.Descriptor && DeviceHeader->KsDevice.Descriptor->Dispatch)
    {
        /* does the device want pnp notifications */
        Dispatch = (PKSDEVICE_DISPATCH)DeviceHeader->KsDevice.Descriptor->Dispatch;
    }
 
    switch (IoStack->MinorFunction)
    {
        case IRP_MN_START_DEVICE:
        {
            return IKsDevice_PnpStartDevice(DeviceObject, Irp);
        }
 
        case IRP_MN_QUERY_STOP_DEVICE:
        {
            Status = STATUS_SUCCESS;
            /* check for pnp notification support */
            if (Dispatch)
            {
                /* check for query stop support */
                if (Dispatch->QueryStop)
                {
                    /* call driver's query stop */
                    Status = Dispatch->QueryStop(&DeviceHeader->KsDevice, Irp);
                    ASSERT(Status != STATUS_PENDING);
                }
            }
 
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Driver: query stop failed %x\n", Status);
                Irp->IoStatus.Status = Status;
                CompleteRequest(Irp, IO_NO_INCREMENT);
                return Status;
            }
 
            /* pass the irp down the driver stack */
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(DeviceHeader->KsDevice.NextDeviceObject, Irp);
        }
 
        case IRP_MN_REMOVE_DEVICE:
        {
            /* Clean up */
            if (Dispatch)
            {
                /* check for remove support */
                if (Dispatch->Remove)
                {
                    /* call driver's stop routine */
                    Dispatch->Remove(&DeviceHeader->KsDevice, Irp);
                }
            }
 
            /* pass the irp down the driver stack */
            IoSkipCurrentIrpStackLocation(Irp);
            Status = IoCallDriver(DeviceHeader->KsDevice.NextDeviceObject, Irp);
            /* FIXME delete device resources */
            return Status;
        }
        case IRP_MN_QUERY_INTERFACE:
        {
            Status = STATUS_UNSUCCESSFUL;
            /* check for pnp notification support */
            if (Dispatch)
            {
                /* check for query interface support */
                if (Dispatch->QueryInterface)
                {
                    /* call driver's query interface */
                    Status = Dispatch->QueryInterface(&DeviceHeader->KsDevice, Irp);
                    ASSERT(Status != STATUS_PENDING);
                }
            }
 
            if (NT_SUCCESS(Status))
            {
                /* driver supports a private interface */
                DPRINT1("IRP_MN_QUERY_INTERFACE Device supports interface\n");
                Irp->IoStatus.Status = Status;
                CompleteRequest(Irp, IO_NO_INCREMENT);
                return Status;
            }
 
            /* pass the irp down the driver stack */
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(DeviceHeader->KsDevice.NextDeviceObject, Irp);
        }
        case IRP_MN_QUERY_DEVICE_RELATIONS:
        {
            /* pass the irp down the driver stack */
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(DeviceHeader->KsDevice.NextDeviceObject, Irp);
        }
        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
        {
            /* pass the irp down the driver stack */
            //Status = KspForwardIrpSynchronous(DeviceObject, Irp);
            Status = Irp->IoStatus.Status;
            DPRINT("IRP_MN_FILTER_RESOURCE_REQUIREMENTS Next Device: Status %x\n", Status);
 
            //Irp->IoStatus.Status = Status;
            CompleteRequest(Irp, IO_NO_INCREMENT);
            return Status;
        }
       case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
       {
            /* pass the irp down the driver stack */
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(DeviceHeader->KsDevice.NextDeviceObject, Irp);
       }
       default:
            DPRINT1("unhandled function %u\n", IoStack->MinorFunction);
            /* pass the irp down the driver stack */
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(DeviceHeader->KsDevice.NextDeviceObject, Irp);
    }
}

Referenced by KsDispatchIrp(), and KsInitializeDriver().

IKsDevice_Power()

NTSTATUS NTAPI IKsDevice_Power	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 549 of file device.c.

{
    UNIMPLEMENTED;
 
    /* TODO */
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    CompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}

Referenced by KsDispatchIrp(), and KsInitializeDriver().

IKsFilter_AddPin()

VOID IKsFilter_AddPin	(	PKSFILTER	Filter,
		PKSPIN	Pin
	)

Definition at line 1337 of file filter.c.

{
    PKSPIN NextPin, CurPin;
    PKSBASIC_HEADER BasicHeader;
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Filter);
 
    /* sanity check */
    ASSERT(Pin->Id < This->Filter.Descriptor->PinDescriptorsCount);
 
    if (This->FirstPin[Pin->Id] == NULL)
    {
        /* welcome first pin */
        This->FirstPin[Pin->Id] = Pin;
        This->PinInstanceCount[Pin->Id]++;
        return;
    }
 
    /* get first pin */
    CurPin = This->FirstPin[Pin->Id];
 
    do
    {
        /* get next instantiated pin */
        NextPin = KsPinGetNextSiblingPin(CurPin);
        if (!NextPin)
            break;
 
        NextPin = CurPin;
 
    }while(NextPin != NULL);
 
    /* get basic header */
    BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)CurPin - sizeof(KSBASIC_HEADER));
 
    /* store pin */
    BasicHeader->Next.Pin = Pin;
}

Referenced by KspCreatePin().

IKsFilter_RemovePin()

VOID IKsFilter_RemovePin	(	PKSFILTER	Filter,
		PKSPIN	Pin
	)

Definition at line 1378 of file filter.c.

{
    PKSPIN NextPin, CurPin, LastPin;
    PKSBASIC_HEADER BasicHeader;
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Filter);
 
    /* sanity check */
    ASSERT(Pin->Id < This->Filter.Descriptor->PinDescriptorsCount);
 
    /* get first pin */
    CurPin = This->FirstPin[Pin->Id];
 
    LastPin = NULL;
    do
    {
        /* get next instantiated pin */
        NextPin = KsPinGetNextSiblingPin(CurPin);
 
        if (CurPin == Pin)
        {
            if (LastPin)
            {
                /* get basic header of last pin */
                BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)LastPin - sizeof(KSBASIC_HEADER));
 
                BasicHeader->Next.Pin = NextPin;
            }
            else
            {
                /* erase last pin */
                This->FirstPin[Pin->Id] = NextPin;
            }
            /* decrement pin instance count */
            This->PinInstanceCount[Pin->Id]--;
            return;
        }
 
        if (!NextPin)
            break;
 
        LastPin = CurPin;
        NextPin = CurPin;
 
    }while(NextPin != NULL);
 
    /* pin not found */
    ASSERT(0);
}

Referenced by IKsPin_Close(), and KspCreatePin().

IKsFilterFactory_Create()

NTSTATUS NTAPI IKsFilterFactory_Create	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 42 of file filterfactory.c.

{
    PKSOBJECT_CREATE_ITEM CreateItem;
    IKsFilterFactoryImpl * Factory;
    IKsFilterFactory * iface;
    NTSTATUS Status;
 
    /* access the create item */
    CreateItem = KSCREATE_ITEM_IRP_STORAGE(Irp);
    if (!CreateItem)
    {
        DPRINT1("IKsFilterFactory_Create no CreateItem\n");
        return STATUS_UNSUCCESSFUL;
    }
 
    /* get filter factory interface */
    Factory = (IKsFilterFactoryImpl*)CONTAINING_RECORD(CreateItem->Context, IKsFilterFactoryImpl, FilterFactory);
 
    /* get interface */
    iface = (IKsFilterFactory*)&Factory->Header.OuterUnknown;
 
    /* create a filter instance */
    Status = KspCreateFilter(DeviceObject, Irp, iface);
 
    DPRINT("KspCreateFilter Status %x\n", Status);
 
    if (Status != STATUS_PENDING)
    {
        Irp->IoStatus.Information = 0;
        Irp->IoStatus.Status = Status;
        CompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    return Status;
}

Referenced by IKsFilterFactory_fnInitialize(), KsFilterFactoryAddCreateItem(), and KspSetFilterFactoriesState().

KspAddCreateItemToList()

NTSTATUS KspAddCreateItemToList	(	OUT PLIST_ENTRY	ListHead,
		IN ULONG	ItemsCount,
		IN PKSOBJECT_CREATE_ITEM	ItemsList
	)

Definition at line 458 of file api.c.

{
    ULONG Index;
    PCREATE_ITEM_ENTRY Entry;
 
    /* add the items */
    for(Index = 0; Index < ItemsCount; Index++)
    {
        /* allocate item */
        Entry = AllocateItem(NonPagedPool, sizeof(CREATE_ITEM_ENTRY));
        if (!Entry)
        {
            /* no memory */
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        /* initialize entry */
        InitializeListHead(&Entry->ObjectItemList);
        Entry->CreateItem = &ItemsList[Index];
        Entry->ReferenceCount = 0;
        Entry->ItemFreeCallback = NULL;
 
        InsertTailList(ListHead, &Entry->Entry);
    }
    return STATUS_SUCCESS;
}

Referenced by KsAllocateDeviceHeader(), and KsAllocateObjectHeader().

KspCopyCreateRequest()

NTSTATUS KspCopyCreateRequest	(	IN PIRP	Irp,
		IN LPWSTR	ObjectClass,
		IN OUT PULONG	Size,
		OUT PVOID *	Result
	)

Definition at line 44 of file misc.c.

{
    PIO_STACK_LOCATION IoStack;
    SIZE_T ObjectLength, ParametersLength;
    PVOID Buffer;
 
    /* get current irp stack */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* get object class length */
    ObjectLength = (wcslen(ObjectClass) + 1) * sizeof(WCHAR);
 
    /* check for minium length requirement */
    if (ObjectLength  + *Size > IoStack->FileObject->FileName.MaximumLength)
        return STATUS_UNSUCCESSFUL;
 
    /* extract parameters length */
    ParametersLength = IoStack->FileObject->FileName.MaximumLength - ObjectLength;
 
    /* allocate buffer */
    Buffer = AllocateItem(NonPagedPool, ParametersLength);
    if (!Buffer)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    /* copy parameters */
    RtlMoveMemory(Buffer, &IoStack->FileObject->FileName.Buffer[ObjectLength / sizeof(WCHAR)], ParametersLength);
 
    /* store result */
    *Result = Buffer;
    *Size = (ULONG)ParametersLength;
 
    return STATUS_SUCCESS;
}

Referenced by KspValidateConnectRequest(), KsValidateAllocatorCreateRequest(), KsValidateClockCreateRequest(), and KsValidateTopologyNodeCreateRequest().

KspCreateFilter()

NTSTATUS NTAPI KspCreateFilter	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN IKsFilterFactory *	iface
	)

Definition at line 1636 of file filter.c.

{
    IKsFilterImpl * This;
    IKsDevice *KsDevice;
    PKSFILTERFACTORY Factory;
    PIO_STACK_LOCATION IoStack;
    PDEVICE_EXTENSION DeviceExtension;
    NTSTATUS Status;
    PKSOBJECT_CREATE_ITEM CreateItem;
 
    /* get device extension */
    DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    /* get the filter factory */
    Factory = iface->lpVtbl->GetStruct(iface);
 
    if (!Factory || !Factory->FilterDescriptor)
    {
        /* Sorry it just will not work */
        return STATUS_UNSUCCESSFUL;
    }
 
    if (Factory->FilterDescriptor->Flags & KSFILTER_FLAG_DENY_USERMODE_ACCESS)
    {
        if (Irp->RequestorMode == UserMode)
        {
            /* filter not accessible from user mode */
            DPRINT1("Access denied\n");
            return STATUS_UNSUCCESSFUL;
        }
    }
 
    /* allocate filter instance */
    This = AllocateItem(NonPagedPool, sizeof(IKsFilterImpl));
    if (!This)
    {
        DPRINT1("KspCreateFilter OutOfMemory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* initialize object bag */
    This->Filter.Bag = AllocateItem(NonPagedPool, sizeof(KSIOBJECT_BAG));
    if (!This->Filter.Bag)
    {
        /* no memory */
        FreeItem(This);
        DPRINT1("KspCreateFilter OutOfMemory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    KsDevice = (IKsDevice*)&DeviceExtension->DeviceHeader->BasicHeader.OuterUnknown;
    KsDevice->lpVtbl->InitializeObjectBag(KsDevice, (PKSIOBJECT_BAG)This->Filter.Bag, NULL);
 
    /* copy filter descriptor */
    Status = IKsFilter_CopyFilterDescriptor(This, Factory->FilterDescriptor);
    if (!NT_SUCCESS(Status))
    {
        /* not enough memory */
        FreeItem(This->Filter.Bag);
        FreeItem(This);
        DPRINT("KspCreateFilter IKsFilter_CopyFilterDescriptor failed %lx\n", Status);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* get current irp stack */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* allocate create items */
    CreateItem = AllocateItem(NonPagedPool, sizeof(KSOBJECT_CREATE_ITEM) * 2);
    if (!CreateItem)
    {
        /* no memory */
        FreeItem(This->Filter.Bag);
        FreeItem(This);
        DPRINT1("KspCreateFilter OutOfMemory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* initialize pin create item */
    CreateItem[0].Create = IKsFilter_DispatchCreatePin;
    CreateItem[0].Context = (PVOID)This;
    CreateItem[0].Flags = KSCREATE_ITEM_FREEONSTOP;
    RtlInitUnicodeString(&CreateItem[0].ObjectClass, KSSTRING_Pin);
    /* initialize node create item */
    CreateItem[1].Create = IKsFilter_DispatchCreateNode;
    CreateItem[1].Context = (PVOID)This;
    CreateItem[1].Flags = KSCREATE_ITEM_FREEONSTOP;
    RtlInitUnicodeString(&CreateItem[1].ObjectClass, KSSTRING_TopologyNode);
 
 
    /* initialize filter instance */
    This->ref = 1;
    This->Header.OuterUnknown = (PUNKNOWN)&vt_IKsFilter;
    This->lpVtblKsControl = &vt_IKsControl;
    This->lpVtblKsProcessingObject = &vt_IKsProcessingObject;
 
    This->Factory = Factory;
    This->FilterFactory = iface;
    This->FileObject = IoStack->FileObject;
    KeInitializeMutex(&This->ProcessingMutex, 0);
 
    /* initialize basic header */
    This->Header.KsDevice = &DeviceExtension->DeviceHeader->KsDevice;
    This->Header.Parent.KsFilterFactory = iface->lpVtbl->GetStruct(iface);
    This->Header.Type = KsObjectTypeFilter;
    This->Header.ControlMutex = &This->ControlMutex;
    KeInitializeMutex(This->Header.ControlMutex, 0);
    InitializeListHead(&This->Header.EventList);
    KeInitializeSpinLock(&This->Header.EventListLock);
 
    /* initialize and gate */
    KsGateInitializeAnd(&This->Gate, NULL);
 
    /* FIXME initialize and gate based on pin flags */
 
    /* initialize work item */
    ExInitializeWorkItem(&This->WorkItem, IKsFilter_FilterCentricWorker, (PVOID)This->lpVtblKsProcessingObject);
 
    /* allocate counted work item */
    Status = KsRegisterCountedWorker(HyperCriticalWorkQueue, &This->WorkItem, &This->Worker);
    if (!NT_SUCCESS(Status))
    {
        /* what can go wrong, goes wrong */
        DPRINT1("KsRegisterCountedWorker failed with %lx\n", Status);
        FreeItem(This);
        FreeItem(CreateItem);
        return Status;
    }
 
    /* allocate the stream descriptors */
    Status = IKsFilter_CreateDescriptors(This, (PKSFILTER_DESCRIPTOR)Factory->FilterDescriptor);
    if (!NT_SUCCESS(Status))
    {
        /* what can go wrong, goes wrong */
        DPRINT1("IKsFilter_CreateDescriptors failed with %lx\n", Status);
        KsUnregisterWorker(This->Worker);
        FreeItem(This);
        FreeItem(CreateItem);
        return Status;
    }
 
 
 
    /* does the filter have a filter dispatch */
    if (Factory->FilterDescriptor->Dispatch)
    {
        /* does it have a create routine */
        if (Factory->FilterDescriptor->Dispatch->Create)
        {
            /* now let driver initialize the filter instance */
 
            ASSERT(This->Header.KsDevice);
            ASSERT(This->Header.KsDevice->Started);
            Status = Factory->FilterDescriptor->Dispatch->Create(&This->Filter, Irp);
 
            if (!NT_SUCCESS(Status) && Status != STATUS_PENDING)
            {
                /* driver failed to initialize */
                DPRINT1("Driver: Status %x\n", Status);
 
                /* free filter instance */
                KsUnregisterWorker(This->Worker);
                FreeItem(This);
                FreeItem(CreateItem);
                return Status;
            }
        }
    }
 
    /* now allocate the object header */
    Status = KsAllocateObjectHeader((PVOID*)&This->ObjectHeader, 2, CreateItem, Irp, &DispatchTable);
    if (!NT_SUCCESS(Status))
    {
        /* failed to allocate object header */
        DPRINT1("Failed to allocate object header %x\n", Status);
 
        return Status;
    }
 
    /* initialize object header extra fields */
    This->ObjectHeader->Type = KsObjectTypeFilter;
    This->ObjectHeader->Unknown = (PUNKNOWN)&This->Header.OuterUnknown;
    This->ObjectHeader->ObjectType = (PVOID)&This->Filter;
 
    /* attach filter to filter factory */
    IKsFilter_AttachFilterToFilterFactory(This, This->Header.Parent.KsFilterFactory);
 
    /* completed initialization */
    DPRINT1("KspCreateFilter done %lx KsDevice %p\n", Status, This->Header.KsDevice);
    return Status;
}

Referenced by IKsFilterFactory_Create().

KspCreateFilterFactory()

NTSTATUS NTAPI KspCreateFilterFactory	(	IN PDEVICE_OBJECT	DeviceObject,
		IN const KSFILTER_DESCRIPTOR *	Descriptor,
		IN PWSTR RefString	OPTIONAL,
		IN PSECURITY_DESCRIPTOR SecurityDescriptor	OPTIONAL,
		IN ULONG	CreateItemFlags,
		IN PFNKSFILTERFACTORYPOWER SleepCallback	OPTIONAL,
		IN PFNKSFILTERFACTORYPOWER WakeCallback	OPTIONAL,
		OUT PKSFILTERFACTORY *FilterFactory	OPTIONAL
	)

Definition at line 359 of file filterfactory.c.

{
    IKsFilterFactoryImpl * This;
    IKsFilterFactory * Filter;
    NTSTATUS Status;
 
    DPRINT("KsCreateFilterFactory\n");
 
    /* Lets allocate a filterfactory */
    This = AllocateItem(NonPagedPool, sizeof(IKsFilterFactoryImpl));
    if (!This)
    {
        /* not enough memory */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* initialize struct */
    This->ref = 1;
    This->Header.OuterUnknown = (PUNKNOWN)&vt_IKsFilterFactoryVtbl;
 
    /* map to com object */
    Filter = (IKsFilterFactory*)&This->Header.OuterUnknown;
 
    /* initialize filter */
    Status = Filter->lpVtbl->Initialize(Filter, DeviceObject, Descriptor, RefString, SecurityDescriptor, CreateItemFlags, SleepCallback, WakeCallback, FilterFactory);
    /* did we succeed */
    if (!NT_SUCCESS(Status))
    {
        /* destroy filterfactory */
        Filter->lpVtbl->Release(Filter);
    }
 
    /* return result */
    DPRINT("KsCreateFilterFactory %x\n", Status);
    /* sanity check */
    ASSERT(Status == STATUS_SUCCESS);
 
    return Status;
}

Referenced by KsCreateFilterFactory(), and KsInitializeDevice().

KspCreateObjectType()

NTSTATUS NTAPI KspCreateObjectType	(	IN HANDLE	ParentHandle,
		IN LPWSTR	ObjectType,
		PVOID	CreateParameters,
		UINT	CreateParametersSize,
		IN ACCESS_MASK	DesiredAccess,
		OUT PHANDLE	NodeHandle
	)

Definition at line 16 of file topology.c.

{
    NTSTATUS Status;
    IO_STATUS_BLOCK IoStatusBlock;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING Name;
 
    /* calculate request length */
    Name.Length = 0;
    Name.MaximumLength = (USHORT)(wcslen(ObjectType) * sizeof(WCHAR) + CreateParametersSize +  1 * sizeof(WCHAR));
    Name.MaximumLength += sizeof(WCHAR);
    /* acquire request buffer */
    Name.Buffer = AllocateItem(NonPagedPool, Name.MaximumLength);
    /* check for success */
    if (!Name.Buffer)
    {
        /* insufficient resources */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* build a request which looks like {ObjectClass}\CreateParameters
     * For pins the parent is the reference string used in registration
     * For clocks it is full path for pin\{ClockGuid}\ClockCreateParams
     */
    RtlAppendUnicodeToString(&Name, ObjectType);
    RtlAppendUnicodeToString(&Name, L"\\");
    /* append create parameters */
    RtlMoveMemory(Name.Buffer + (Name.Length / sizeof(WCHAR)), CreateParameters, CreateParametersSize);
    Name.Length += CreateParametersSize;
    Name.Buffer[Name.Length / 2] = L'\0';
 
    InitializeObjectAttributes(&ObjectAttributes, &Name, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE | OBJ_OPENIF, ParentHandle, NULL);
    /* create the instance */
    Status = IoCreateFile(NodeHandle,
                          DesiredAccess,
                          &ObjectAttributes,
                          &IoStatusBlock,
                          NULL,
                          0,
                          0,
                          FILE_OPEN,
                          0,
                          NULL,
                          0,
                          CreateFileTypeNone,
                          NULL,
                          IO_NO_PARAMETER_CHECKING | IO_FORCE_ACCESS_CHECK);
 
    /* free request buffer */
    FreeItem(Name.Buffer);
    return Status;
}

Referenced by KsCreateAllocator(), KsCreateClock(), KsCreatePin(), and KsCreateTopologyNode().

KspCreatePin()

NTSTATUS KspCreatePin	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PKSDEVICE	KsDevice,
		IN IKsFilterFactory *	FilterFactory,
		IN IKsFilter *	Filter,
		IN PKSPIN_CONNECT	Connect,
		IN KSPIN_DESCRIPTOR_EX *	Descriptor
	)

Definition at line 2283 of file pin.c.

{
    IKsPinImpl * This;
    PIO_STACK_LOCATION IoStack;
    IKsDevice * Device;
    PDEVICE_EXTENSION DeviceExtension;
    PKSOBJECT_CREATE_ITEM CreateItem;
    NTSTATUS Status;
    PKSDATAFORMAT DataFormat;
    PKSBASIC_HEADER BasicHeader;
    ULONG Index;
    ULONG FrameSize = 0;
    ULONG NumFrames = 0;
    KSAUTOMATION_TABLE AutomationTable;
 
    /* sanity checks */
    ASSERT(Descriptor->Dispatch);
 
    DPRINT("KspCreatePin PinId %lu Flags %x\n", Connect->PinId, Descriptor->Flags);
 
//Output Pin: KSPIN_FLAG_PROCESS_IN_RUN_STATE_ONLY
//Input Pin: KSPIN_FLAG_FIXED_FORMAT|KSPIN_FLAG_DO_NOT_USE_STANDARD_TRANSPORT|KSPIN_FLAG_FRAMES_NOT_REQUIRED_FOR_PROCESSING
 
    DPRINT("KspCreatePin Dataflow %lu\n", Descriptor->PinDescriptor.DataFlow);
    DPRINT("KspCreatePin Communication %lu\n", Descriptor->PinDescriptor.Communication);
    if (Descriptor->AllocatorFraming)
    {
        DPRINT("KspCreatePin CountItems %lu\n", Descriptor->AllocatorFraming->CountItems);
        DPRINT("KspCreatePin PinFlags %lx\n", Descriptor->AllocatorFraming->PinFlags);
        DPRINT("KspCreatePin OutputCompression RatioNumerator %lu RatioDenominator  %lu RatioConstantMargin %lu\n", Descriptor->AllocatorFraming->OutputCompression.RatioNumerator,
               Descriptor->AllocatorFraming->OutputCompression.RatioDenominator, Descriptor->AllocatorFraming->OutputCompression.RatioConstantMargin);
        DPRINT("KspCreatePin PinWeight %lx\n", Descriptor->AllocatorFraming->PinWeight);
 
        for(Index = 0; Index < Descriptor->AllocatorFraming->CountItems; Index++)
        {
            DPRINT("KspCreatePin Index %lu MemoryFlags %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].MemoryFlags);
            DPRINT("KspCreatePin Index %lu BusFlags %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].BusFlags);
            DPRINT("KspCreatePin Index %lu Flags %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].Flags);
            DPRINT("KspCreatePin Index %lu Frames %lu\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].Frames);
            DPRINT("KspCreatePin Index %lu FileAlignment %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].FileAlignment);
            DPRINT("KspCreatePin Index %lu MemoryTypeWeight %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].MemoryTypeWeight);
            DPRINT("KspCreatePin Index %lu PhysicalRange MinFrameSize %lu MaxFrameSize %lu Stepping %lu\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].PhysicalRange.MinFrameSize,
                   Descriptor->AllocatorFraming->FramingItem[Index].PhysicalRange.MaxFrameSize,
                   Descriptor->AllocatorFraming->FramingItem[Index].PhysicalRange.Stepping);
 
            DPRINT("KspCreatePin Index %lu FramingRange  MinFrameSize %lu MaxFrameSize %lu Stepping %lu InPlaceWeight %lu NotInPlaceWeight %lu\n",
                   Index,
                   Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.Range.MinFrameSize,
                   Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.Range.MaxFrameSize,
                   Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.Range.Stepping,
                   Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.InPlaceWeight,
                   Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.NotInPlaceWeight);
 
           FrameSize = Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.Range.MaxFrameSize;
           NumFrames = Descriptor->AllocatorFraming->FramingItem[Index].Frames;
        }
    }
 
     for (Index = 0; Index < Descriptor->PinDescriptor.DataRangesCount; Index++)
     {
         UNICODE_STRING GuidString;
         /* convert the guid to string */
         RtlStringFromGUID(&Descriptor->PinDescriptor.DataRanges[Index]->MajorFormat, &GuidString);
         DPRINT("Index %lu MajorFormat %S\n", Index, GuidString.Buffer);
         RtlStringFromGUID(&Descriptor->PinDescriptor.DataRanges[Index]->SubFormat, &GuidString);
         DPRINT("Index %lu SubFormat %S\n", Index, GuidString.Buffer);
         RtlStringFromGUID(&Descriptor->PinDescriptor.DataRanges[Index]->Specifier, &GuidString);
         DPRINT("Index %lu Specifier %S\n", Index, GuidString.Buffer);
         RtlStringFromGUID(&Descriptor->PinDescriptor.DataRanges[Index]->Specifier, &GuidString);
         DPRINT("Index %lu FormatSize %lu Flags %lu SampleSize %lu Reserved %lu KSDATAFORMAT %lu\n", Index,
                Descriptor->PinDescriptor.DataRanges[Index]->FormatSize, Descriptor->PinDescriptor.DataRanges[Index]->Flags, Descriptor->PinDescriptor.DataRanges[Index]->SampleSize, Descriptor->PinDescriptor.DataRanges[Index]->Reserved, sizeof(KSDATAFORMAT));
 
         if (IsEqualGUIDAligned(&Descriptor->PinDescriptor.DataRanges[Index]->SubFormat, &KSDATAFORMAT_SUBTYPE_BDA_MPEG2_TRANSPORT))
         {
#if !defined(NDEBUG)
             PKS_DATARANGE_BDA_TRANSPORT Transport = (PKS_DATARANGE_BDA_TRANSPORT)&Descriptor->PinDescriptor.DataRanges[Index];
             DPRINT("KSDATAFORMAT_SUBTYPE_BDA_MPEG2_TRANSPORT AvgTimePerFrame %I64u ulcbPhyiscalFrame %lu ulcbPhyiscalFrameAlignment %lu ulcbPhyiscalPacket %lu\n", Transport->BdaTransportInfo.AvgTimePerFrame, Transport->BdaTransportInfo.ulcbPhyiscalFrame,
                    Transport->BdaTransportInfo.ulcbPhyiscalFrameAlignment, Transport->BdaTransportInfo.ulcbPhyiscalPacket);
#endif
         }
    }
    if (!FrameSize)
    {
        /* default to 50 * 188 (MPEG2 TS packet size) */
        FrameSize = 9400;
    }
 
    if (!NumFrames)
    {
        NumFrames = 8;
    }
 
    /* get current irp stack */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* get device extension */
    DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    /* get ks device interface */
    Device = (IKsDevice*)&DeviceExtension->DeviceHeader->BasicHeader.OuterUnknown;
 
    /* first allocate pin ctx */
    This = AllocateItem(NonPagedPool, sizeof(IKsPinImpl));
    if (!This)
    {
        /* not enough memory */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* allocate create item */
    CreateItem = AllocateItem(NonPagedPool, sizeof(KSOBJECT_CREATE_ITEM) * 3);
    if (!CreateItem)
    {
        /* not enough memory */
        FreeItem(This);
        DPRINT("KspCreatePin OutOfMemory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* initialize basic header */
    This->BasicHeader.KsDevice = KsDevice;
    This->BasicHeader.Type = KsObjectTypePin;
    This->BasicHeader.Parent.KsFilter = Filter->lpVtbl->GetStruct(Filter);
    This->BasicHeader.OuterUnknown = (PUNKNOWN)&vt_IKsPin;
    InitializeListHead(&This->BasicHeader.EventList);
    KeInitializeSpinLock(&This->BasicHeader.EventListLock);
 
    ASSERT(This->BasicHeader.Parent.KsFilter);
 
    BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)This->BasicHeader.Parent.KsFilter - sizeof(KSBASIC_HEADER));
 
    This->BasicHeader.ControlMutex = BasicHeader->ControlMutex;
    ASSERT(This->BasicHeader.ControlMutex);
 
    InitializeListHead(&This->BasicHeader.EventList);
    KeInitializeSpinLock(&This->BasicHeader.EventListLock);
 
    /* initialize pin */
    This->FrameSize = FrameSize;
    This->NumFrames = NumFrames;
    This->lpVtblReferenceClock = &vt_ReferenceClock;
    This->ref = 1;
    This->FileObject = IoStack->FileObject;
    This->Filter = Filter;
    KeInitializeMutex(&This->ProcessingMutex, 0);
    InitializeListHead(&This->IrpList);
    KeInitializeSpinLock(&This->IrpListLock);
 
    /* allocate object bag */
    This->Pin.Bag = AllocateItem(NonPagedPool, sizeof(KSIOBJECT_BAG));
    if (!This->Pin.Bag)
    {
        /* not enough memory */
        FreeItem(This);
        FreeItem(CreateItem);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* initialize object bag */
    Device->lpVtbl->InitializeObjectBag(Device, This->Pin.Bag, NULL);
 
    /* allocate pin descriptor */
    This->Pin.Descriptor = AllocateItem(NonPagedPool, sizeof(KSPIN_DESCRIPTOR_EX));
    if (!This->Pin.Descriptor)
    {
        /* not enough memory */
        KsFreeObjectBag(This->Pin.Bag);
        FreeItem(This);
        FreeItem(CreateItem);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* copy pin descriptor */
    RtlMoveMemory((PVOID)This->Pin.Descriptor, Descriptor, sizeof(KSPIN_DESCRIPTOR_EX));
 
    /* initialize automation table */
    RtlZeroMemory(&AutomationTable, sizeof(KSAUTOMATION_TABLE));
 
    AutomationTable.PropertyItemSize = sizeof(KSPROPERTY_ITEM);
    AutomationTable.PropertySets = PinPropertySet;
    AutomationTable.PropertySetsCount = sizeof(PinPropertySet) / sizeof(KSPROPERTY_SET);
 
    /* merge in pin property sets */
    Status = KsMergeAutomationTables((PKSAUTOMATION_TABLE*)&This->Pin.Descriptor->AutomationTable, (PKSAUTOMATION_TABLE)Descriptor->AutomationTable, &AutomationTable, This->Pin.Bag);
 
    if (!NT_SUCCESS(Status))
    {
        /* not enough memory */
        KsFreeObjectBag(This->Pin.Bag);
        FreeItem(This);
        FreeItem(CreateItem);
        return Status;
    }
 
    /* get format */
    DataFormat = (PKSDATAFORMAT)(Connect + 1);
 
    /* initialize pin descriptor */
    This->Pin.Context = NULL;
    This->Pin.Id = Connect->PinId;
    This->Pin.Communication = Descriptor->PinDescriptor.Communication;
    This->Pin.ConnectionIsExternal = FALSE; //FIXME
    RtlMoveMemory(&This->Pin.ConnectionInterface, &Connect->Interface, sizeof(KSPIN_INTERFACE));
    RtlMoveMemory(&This->Pin.ConnectionMedium, &Connect->Medium, sizeof(KSPIN_MEDIUM));
    RtlMoveMemory(&This->Pin.ConnectionPriority, &Connect->Priority, sizeof(KSPRIORITY));
 
    /* allocate format */
    Status = _KsEdit(This->Pin.Bag, (PVOID*)&This->Pin.ConnectionFormat, DataFormat->FormatSize, DataFormat->FormatSize, 0);
    if (!NT_SUCCESS(Status))
    {
        /* failed to allocate format */
        KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
        FreeItem(This);
        FreeItem(CreateItem);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* copy format */
    RtlMoveMemory((PVOID)This->Pin.ConnectionFormat, DataFormat, DataFormat->FormatSize);
 
    This->Pin.AttributeList = NULL; //FIXME
    This->Pin.StreamHeaderSize = sizeof(KSSTREAM_HEADER);
    This->Pin.DataFlow = Descriptor->PinDescriptor.DataFlow;
    This->Pin.DeviceState = KSSTATE_STOP;
    This->Pin.ResetState = KSRESET_END;
    This->Pin.ClientState = KSSTATE_STOP;
 
    /* initialize allocator create item */
    CreateItem[0].Context = (PVOID)&This->Pin;
    CreateItem[0].Create = IKsPin_DispatchCreateAllocator;
    CreateItem[0].Flags = KSCREATE_ITEM_FREEONSTOP;
    RtlInitUnicodeString(&CreateItem[0].ObjectClass, KSSTRING_Allocator);
 
    /* initialize clock create item */
    CreateItem[1].Context = (PVOID)&This->Pin;
    CreateItem[1].Create = IKsPin_DispatchCreateClock;
    CreateItem[1].Flags = KSCREATE_ITEM_FREEONSTOP;
    RtlInitUnicodeString(&CreateItem[1].ObjectClass, KSSTRING_Clock);
 
    /* initialize topology node create item */
    CreateItem[2].Context = (PVOID)&This->Pin;
    CreateItem[2].Create = IKsPin_DispatchCreateNode;
    CreateItem[2].Flags = KSCREATE_ITEM_FREEONSTOP;
    RtlInitUnicodeString(&CreateItem[2].ObjectClass, KSSTRING_TopologyNode);
 
    /* now allocate object header */
    Status = KsAllocateObjectHeader((KSOBJECT_HEADER*)&This->ObjectHeader, 3, CreateItem, Irp, &PinDispatchTable);
    if (!NT_SUCCESS(Status))
    {
        /* failed to create object header */
        DPRINT("KspCreatePin KsAllocateObjectHeader failed %lx\n", Status);
        KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
        FreeItem(This);
        FreeItem(CreateItem);
 
        /* return failure code */
        return Status;
    }
 
     /* add extra info to object header */
    This->ObjectHeader->Type = KsObjectTypePin;
    This->ObjectHeader->Unknown = (PUNKNOWN)&This->BasicHeader.OuterUnknown;
    This->ObjectHeader->ObjectType = (PVOID)&This->Pin;
 
    if (!Descriptor->Dispatch || !Descriptor->Dispatch->Process)
    {
        /* the pin is part of filter-centric processing filter
         * add process pin to filter
         */
        This->ProcessPin.BytesAvailable = 0;
        This->ProcessPin.BytesUsed = 0;
        This->ProcessPin.CopySource = NULL;
        This->ProcessPin.Data = NULL;
        This->ProcessPin.DelegateBranch = NULL;
        This->ProcessPin.Flags = 0;
        This->ProcessPin.InPlaceCounterpart = NULL;
        This->ProcessPin.Pin = &This->Pin;
        This->ProcessPin.StreamPointer = (PKSSTREAM_POINTER)&This->LeadingEdgeStreamPointer.StreamPointer;
        This->ProcessPin.Terminate = FALSE;
 
        Status = Filter->lpVtbl->AddProcessPin(Filter, &This->ProcessPin);
        DPRINT("KspCreatePin AddProcessPin %lx\n", Status);
 
        if (!NT_SUCCESS(Status))
        {
            /* failed to add process pin */
            KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
            KsFreeObjectHeader(&This->ObjectHeader);
            FreeItem(This);
            FreeItem(CreateItem);
            /* return failure code */
            return Status;
        }
    }
    else if (Descriptor->Dispatch && Descriptor->Dispatch->Process)
    {
        /* pin centric processing filter */
 
        /* initialize work item */
        ExInitializeWorkItem(&This->PinWorkQueueItem, IKsPin_PinCentricWorker, (PVOID)This);
 
        /* allocate counted work item */
        Status = KsRegisterCountedWorker(HyperCriticalWorkQueue, &This->PinWorkQueueItem, &This->PinWorker);
 
        if (!NT_SUCCESS(Status))
        {
            DPRINT("Failed to register Worker %lx\n", Status);
            KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
            KsFreeObjectHeader(&This->ObjectHeader);
            FreeItem(This);
            FreeItem(CreateItem);
            return Status;
        }
 
        if (This->Pin.Descriptor->PinDescriptor.DataFlow == KSPIN_DATAFLOW_IN)
            This->LeadingEdgeStreamPointer.StreamPointer.Offset = &This->LeadingEdgeStreamPointer.StreamPointer.OffsetIn;
        else
            This->LeadingEdgeStreamPointer.StreamPointer.Offset = &This->LeadingEdgeStreamPointer.StreamPointer.OffsetOut;
 
 
        KeInitializeEvent(&This->FrameComplete, NotificationEvent, FALSE);
 
    }
 
    /* FIXME add pin instance to filter instance */
    IKsFilter_AddPin(Filter->lpVtbl->GetStruct(Filter), &This->Pin);
 
    if (Descriptor->Dispatch && Descriptor->Dispatch->SetDataFormat)
    {
        Status = Descriptor->Dispatch->SetDataFormat(&This->Pin, NULL, NULL, This->Pin.ConnectionFormat, NULL);
        DPRINT("KspCreatePin SetDataFormat %lx\n", Status);
    }
 
 
    /* does the driver have a pin dispatch */
    if (Descriptor->Dispatch && Descriptor->Dispatch->Create)
    {
        /*  now inform the driver to create a new pin */
        Status = Descriptor->Dispatch->Create(&This->Pin, Irp);
        DPRINT("KspCreatePin DispatchCreate %lx\n", Status);
    }
 
 
    DPRINT("KspCreatePin Status %lx KsDevice %p\n", Status, KsDevice);
 
    if (!NT_SUCCESS(Status) && Status != STATUS_PENDING)
    {
        /* failed to create pin, release resources */
        IKsFilter_RemovePin(Filter->lpVtbl->GetStruct(Filter), &This->Pin);
        KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
        KsFreeObjectHeader((KSOBJECT_HEADER)This->ObjectHeader);
        FreeItem(This);
 
        /* return failure code */
        return Status;
    }
 
    return Status;
}

Referenced by IKsFilter_DispatchCreatePin().

KspEnableEvent()

NTSTATUS KspEnableEvent	(	IN PIRP	Irp,
		IN ULONG	EventSetsCount,
		IN const KSEVENT_SET *	EventSet,
		IN OUT PLIST_ENTRY EventsList	OPTIONAL,
		IN KSEVENTS_LOCKTYPE EventsFlags	OPTIONAL,
		IN PVOID EventsLock	OPTIONAL,
		IN PFNKSALLOCATOR Allocator	OPTIONAL,
		IN ULONG EventItemSize	OPTIONAL
	)

Definition at line 87 of file event.c.

{
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
    KSEVENT Event;
    PKSEVENT_ITEM EventItem, FoundEventItem;
    PKSEVENTDATA EventData;
    const KSEVENT_SET *FoundEventSet;
    PKSEVENT_ENTRY EventEntry;
    ULONG Index, SubIndex, Size;
    PVOID Object;
    KSEVENT_CTX Ctx;
    LPGUID Guid;
 
    /* get current stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(KSEVENT))
    {
        /* invalid parameter */
        return STATUS_NOT_SUPPORTED;
    }
 
    if (Irp->RequestorMode == UserMode)
    {
        _SEH2_TRY
        {
           ProbeForRead(IoStack->Parameters.DeviceIoControl.Type3InputBuffer, sizeof(KSEVENT), sizeof(UCHAR));
           ProbeForRead(Irp->UserBuffer, IoStack->Parameters.DeviceIoControl.OutputBufferLength, sizeof(UCHAR));
           RtlMoveMemory(&Event, IoStack->Parameters.DeviceIoControl.Type3InputBuffer, sizeof(KSEVENT));
           Status = STATUS_SUCCESS;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* Exception, get the error code */
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
 
        /* check for success */
        if (!NT_SUCCESS(Status))
        {
            /* failed to probe parameters */
            return Status;
        }
    }
    else
    {
        /* copy event struct */
        RtlMoveMemory(&Event, IoStack->Parameters.DeviceIoControl.Type3InputBuffer, sizeof(KSEVENT));
    }
 
    FoundEventItem = NULL;
    FoundEventSet = NULL;
 
 
    if (IsEqualGUIDAligned(&Event.Set, &GUID_NULL) && Event.Id == 0 && Event.Flags == KSEVENT_TYPE_SETSUPPORT)
    {
        // store output size
        Irp->IoStatus.Information = sizeof(GUID) * EventSetsCount;
        if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(GUID) * EventSetsCount)
        {
            // buffer too small
            return STATUS_MORE_ENTRIES;
        }
 
        // get output buffer
        Guid = (LPGUID)Irp->UserBuffer;
 
       // copy property guids from property sets
       for(Index = 0; Index < EventSetsCount; Index++)
       {
           RtlMoveMemory(&Guid[Index], EventSet[Index].Set, sizeof(GUID));
       }
       return STATUS_SUCCESS;
    }
 
    /* now try to find event set */
    for(Index = 0; Index < EventSetsCount; Index++)
    {
        if (IsEqualGUIDAligned(&Event.Set, EventSet[Index].Set))
        {
            EventItem = (PKSEVENT_ITEM)EventSet[Index].EventItem;
 
            /* sanity check */
            ASSERT(EventSet[Index].EventsCount);
            ASSERT(EventItem);
 
            /* now find matching event id */
            for(SubIndex = 0; SubIndex < EventSet[Index].EventsCount; SubIndex++)
            {
                if (EventItem[SubIndex].EventId == Event.Id)
                {
                    /* found event item */
                    FoundEventItem = &EventItem[SubIndex];
                    FoundEventSet = &EventSet[Index];
                    break;
                }
            }
 
            if (FoundEventSet)
                break;
        }
    }
 
    if (!FoundEventSet)
    {
        UNICODE_STRING GuidString;
 
        RtlStringFromGUID(&Event.Set, &GuidString);
 
        DPRINT("Guid %S Id %u Flags %x not found\n", GuidString.Buffer, Event.Id, Event.Flags);
        RtlFreeUnicodeString(&GuidString);
        return STATUS_PROPSET_NOT_FOUND;
 
 
    }
 
    if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < FoundEventItem->DataInput)
    {
        /* buffer too small */
        DPRINT1("Got %u expected %u\n", IoStack->Parameters.DeviceIoControl.OutputBufferLength, FoundEventItem->DataInput);
        return STATUS_SUCCESS;
    }
 
    if (!FoundEventItem->AddHandler && !EventsList)
    {
        /* no add handler and no list to add the new entry to */
        return STATUS_INVALID_PARAMETER;
    }
 
    /* get event data */
    EventData = Irp->UserBuffer;
 
    /* sanity check */
    ASSERT(EventData);
 
    if (Irp->RequestorMode == UserMode)
    {
        if (EventData->NotificationType == KSEVENTF_SEMAPHORE_HANDLE)
        {
            /* get semaphore object handle */
            Status = ObReferenceObjectByHandle(EventData->SemaphoreHandle.Semaphore, SEMAPHORE_MODIFY_STATE, *ExSemaphoreObjectType, Irp->RequestorMode, &Object, NULL);
 
            if (!NT_SUCCESS(Status))
            {
                /* invalid semaphore handle */
                return STATUS_INVALID_PARAMETER;
            }
        }
        else if (EventData->NotificationType == KSEVENTF_EVENT_HANDLE)
        {
            /* get event object handle */
            Status = ObReferenceObjectByHandle(EventData->EventHandle.Event, EVENT_MODIFY_STATE, *ExEventObjectType, Irp->RequestorMode, &Object, NULL);
 
            if (!NT_SUCCESS(Status))
            {
                /* invalid event handle */
                return STATUS_INVALID_PARAMETER;
            }
        }
        else
        {
            /* user mode client can only pass an event or semaphore handle */
            return STATUS_INVALID_PARAMETER;
        }
    }
    else
    {
        if (EventData->NotificationType != KSEVENTF_EVENT_OBJECT &&
            EventData->NotificationType != KSEVENTF_SEMAPHORE_OBJECT &&
            EventData->NotificationType != KSEVENTF_DPC &&
            EventData->NotificationType != KSEVENTF_WORKITEM &&
            EventData->NotificationType != KSEVENTF_KSWORKITEM)
        {
            /* invalid type requested */
            return STATUS_INVALID_PARAMETER;
        }
    }
 
 
    /* calculate request size */
    Size = sizeof(KSEVENT_ENTRY) + FoundEventItem->ExtraEntryData;
 
    /* do we have an allocator */
    if (Allocator)
    {
        /* allocate event entry */
        Status = Allocator(Irp, Size, FALSE);
 
        if (!NT_SUCCESS(Status))
        {
            /* failed */
            return Status;
        }
 
        /* assume the caller put it there */
        EventEntry = KSEVENT_ENTRY_IRP_STORAGE(Irp);
 
    }
    else
    {
        /* allocate it from nonpaged pool */
        EventEntry = AllocateItem(NonPagedPool, Size);
    }
 
    if (!EventEntry)
    {
        /* not enough memory */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* zero event entry */
    RtlZeroMemory(EventEntry, Size);
 
    /* initialize event entry */
    EventEntry->EventData = EventData;
    EventEntry->NotificationType = EventData->NotificationType;
    EventEntry->EventItem = FoundEventItem;
    EventEntry->EventSet = FoundEventSet;
    EventEntry->FileObject = IoStack->FileObject;
 
    switch(EventEntry->NotificationType)
    {
        case KSEVENTF_EVENT_HANDLE:
            EventEntry->Object = Object;
            EventEntry->Reserved = 0;
            break;
        case KSEVENTF_SEMAPHORE_HANDLE:
            EventEntry->Object = Object;
            EventEntry->SemaphoreAdjustment = EventData->SemaphoreHandle.Adjustment;
            EventEntry->Reserved = 0;
            break;
        case KSEVENTF_EVENT_OBJECT:
            EventEntry->Object = EventData->EventObject.Event;
            EventEntry->Reserved = EventData->EventObject.Increment;
            break;
        case KSEVENTF_SEMAPHORE_OBJECT:
            EventEntry->Object = EventData->SemaphoreObject.Semaphore;
            EventEntry->SemaphoreAdjustment = EventData->SemaphoreObject.Adjustment;
            EventEntry->Reserved = EventData->SemaphoreObject.Increment;
            break;
        case KSEVENTF_DPC:
            EventEntry->Object = EventData->Dpc.Dpc;
            EventData->Dpc.ReferenceCount = 0;
            break;
        case KSEVENTF_WORKITEM:
            EventEntry->Object = EventData->WorkItem.WorkQueueItem;
            EventEntry->BufferItem = (PKSBUFFER_ITEM)UlongToPtr(EventData->WorkItem.WorkQueueType);
            break;
        case KSEVENTF_KSWORKITEM:
            EventEntry->Object = EventData->KsWorkItem.KsWorkerObject;
            EventEntry->DpcItem = (PKSDPC_ITEM)EventData->KsWorkItem.WorkQueueItem;
            break;
        default:
            /* should not happen */
            ASSERT(0);
    }
 
    if (FoundEventItem->AddHandler)
    {
        /* now add the event */
        Status = FoundEventItem->AddHandler(Irp, EventData, EventEntry);
 
        if (!NT_SUCCESS(Status))
        {
            /* discard event entry */
            KsDiscardEvent(EventEntry);
        }
    }
    else
    {
        /* setup context */
        Ctx.List = EventsList;
        Ctx.EventEntry = EventEntry;
 
         /* add the event */
        (void)KspSynchronizedEventRoutine(EventsFlags, EventsLock, SyncAddEvent, &Ctx);
 
        Status = STATUS_SUCCESS;
    }
 
    /* done */
    return Status;
}

Referenced by _IRQL_requires_max_(), IKsFilter_DispatchDeviceIoControl(), IKsPin_DispatchDeviceIoControl(), and KsEnableEvent().

KspFreeCreateItems()

VOID KspFreeCreateItems

(

IN PLIST_ENTRY

ListHead

)

KspFreeDeviceInterfaces()

NTSTATUS KspFreeDeviceInterfaces

(

IN PLIST_ENTRY

ListHead

)

Definition at line 37 of file deviceinterface.c.

{
    PLIST_ENTRY Entry;
    PSYMBOLIC_LINK_ENTRY SymEntry;
 
    while(!IsListEmpty(ListHead))
    {
        /* remove first entry */
        Entry = RemoveHeadList(ListHead);
 
        /* fetch symbolic link entry */
        SymEntry = (PSYMBOLIC_LINK_ENTRY)CONTAINING_RECORD(Entry, SYMBOLIC_LINK_ENTRY, Entry);
 
        /* free device interface string */
        RtlFreeUnicodeString(&SymEntry->SymbolicLink);
        /* free entry item */
        FreeItem(Entry);
    }
 
    return STATUS_SUCCESS;
}

Referenced by IKsFilterFactory_fnRelease().

KspMethodHandlerWithAllocator()

NTSTATUS NTAPI KspMethodHandlerWithAllocator	(	IN PIRP	Irp,
		IN ULONG	MethodSetsCount,
		IN const KSMETHOD_SET *	MethodSet,
		IN PFNKSALLOCATOR Allocator	OPTIONAL,
		IN ULONG MethodItemSize	OPTIONAL
	)

Definition at line 99 of file methods.c.

{
    PKSMETHOD Method;
    PKSMETHOD_SET Set;
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
    PFNKSHANDLER MethodHandler = NULL;
    ULONG Index;
    LPGUID Guid;
 
    /* get current irp stack */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* check if inputbuffer at least holds KSMETHOD item */
    if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(KSMETHOD))
    {
        /* invalid parameter */
        Irp->IoStatus.Information = sizeof(KSPROPERTY);
        return STATUS_INVALID_BUFFER_SIZE;
    }
 
    /* FIXME probe the input / output buffer if from user mode */
 
    /* get input property request */
    Method = (PKSMETHOD)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
 
//    DPRINT("KspMethodHandlerWithAllocator Irp %p PropertySetsCount %u PropertySet %p Allocator %p PropertyItemSize %u ExpectedPropertyItemSize %u\n", Irp, PropertySetsCount, PropertySet, Allocator, PropertyItemSize, sizeof(KSPROPERTY_ITEM));
 
    /* sanity check */
    ASSERT(MethodItemSize == 0 || MethodItemSize == sizeof(KSMETHOD_ITEM));
 
    /* find the method handler */
    Status = FindMethodHandler(&Irp->IoStatus, MethodSet, MethodSetsCount, Method, IoStack->Parameters.DeviceIoControl.InputBufferLength, IoStack->Parameters.DeviceIoControl.OutputBufferLength, Irp->UserBuffer, &MethodHandler, &Set);
 
    if (NT_SUCCESS(Status) && MethodHandler)
    {
        /* call method handler */
        KSMETHOD_SET_IRP_STORAGE(Irp) = Set;
        Status = MethodHandler(Irp, Method, Irp->UserBuffer);
 
        if (Status == STATUS_BUFFER_TOO_SMALL)
        {
            /* output buffer is too small */
            if (Allocator)
            {
                /* allocate the requested amount */
                Status = Allocator(Irp, (ULONG)Irp->IoStatus.Information, FALSE);
 
                /* check if the block was allocated */
                if (!NT_SUCCESS(Status))
                {
                    /* no memory */
                    return STATUS_INSUFFICIENT_RESOURCES;
                }
 
                /* re-call method handler */
                Status = MethodHandler(Irp, Method, Irp->UserBuffer);
            }
        }
    }
    else if (IsEqualGUIDAligned(&Method->Set, &GUID_NULL) && Method->Id == 0 && Method->Flags == KSMETHOD_TYPE_SETSUPPORT)
    {
        // store output size
        Irp->IoStatus.Information = sizeof(GUID) * MethodSetsCount;
        if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(GUID) * MethodSetsCount)
        {
            // buffer too small
            return STATUS_MORE_ENTRIES;
        }
 
        // get output buffer
        Guid = (LPGUID)Irp->UserBuffer;
 
       // copy property guids from property sets
       for(Index = 0; Index < MethodSetsCount; Index++)
       {
           RtlMoveMemory(&Guid[Index], MethodSet[Index].Set, sizeof(GUID));
       }
       return STATUS_SUCCESS;
    }
 
    /* done */
    return Status;
}

Referenced by _IRQL_requires_max_(), IKsFilter_DispatchDeviceIoControl(), and IKsPin_DispatchDeviceIoControl().

KspPinPropertyHandler()

KSDDKAPI NTSTATUS NTAPI KspPinPropertyHandler	(	IN PIRP	Irp,
		IN PKSPROPERTY	Property,
		IN OUT PVOID	Data,
		IN ULONG	DescriptorsCount,
		IN const KSPIN_DESCRIPTOR *	Descriptors,
		IN ULONG	DescriptorSize
	)

Definition at line 324 of file connectivity.c.

{
    KSP_PIN * Pin;
    KSMULTIPLE_ITEM * Item;
    PIO_STACK_LOCATION IoStack;
    ULONG Size, Index;
    PVOID Buffer;
    PKSDATARANGE_AUDIO *WaveFormatOut;
    PKSDATAFORMAT_WAVEFORMATEX WaveFormatIn;
    PKEY_VALUE_PARTIAL_INFORMATION KeyInfo;
    const KSPIN_DESCRIPTOR *Descriptor;
    NTSTATUS Status = STATUS_NOT_SUPPORTED;
    ULONG Count;
    const PKSDATARANGE* DataRanges;
    LPGUID Guid;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    Buffer = Data;
 
    //DPRINT("KsPinPropertyHandler Irp %p Property %p Data %p DescriptorsCount %u Descriptor %p OutputLength %u Id %u\n", Irp, Property, Data, DescriptorsCount, Descriptor, IoStack->Parameters.DeviceIoControl.OutputBufferLength, Property->Id);
 
    /* convert to PKSP_PIN */
    Pin = (KSP_PIN*)Property;
 
    if (Property->Id != KSPROPERTY_PIN_CTYPES)
    {
        if (Pin->PinId >= DescriptorsCount)
        {
            /* invalid parameter */
            return STATUS_INVALID_PARAMETER;
        }
    }
    else
    {
        (*(PULONG)Buffer) = DescriptorsCount;
        Irp->IoStatus.Information = sizeof(ULONG);
        return STATUS_SUCCESS;
    }
 
 
    if (DescriptorSize == sizeof(KSPIN_DESCRIPTOR))
    {
        /* it is simple pin descriptor */
        Descriptor = &Descriptors[Pin->PinId];
    }
    else
    {
        /* get offset to pin descriptor */
        Descriptor = &(((PKSPIN_DESCRIPTOR_EX)((ULONG_PTR)Descriptors + Pin->PinId * DescriptorSize))->PinDescriptor);
    }
 
    switch(Property->Id)
    {
        case KSPROPERTY_PIN_DATAFLOW:
 
            Size = sizeof(KSPIN_DATAFLOW);
            if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < Size)
            {
                Irp->IoStatus.Information = Size;
                Status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            *((KSPIN_DATAFLOW*)Buffer) = Descriptor->DataFlow;
            Irp->IoStatus.Information = sizeof(KSPIN_DATAFLOW);
            Status = STATUS_SUCCESS;
            break;
 
        case KSPROPERTY_PIN_DATARANGES:
        case KSPROPERTY_PIN_CONSTRAINEDDATARANGES:
 
            Size = sizeof(KSMULTIPLE_ITEM);
            DPRINT("Id %lu PinId %lu DataRangesCount %lu ConstrainedDataRangesCount %lu\n", Property->Id, Pin->PinId, Descriptor->DataRangesCount, Descriptor->ConstrainedDataRangesCount);
 
            if (Property->Id == KSPROPERTY_PIN_DATARANGES || Descriptor->ConstrainedDataRangesCount == 0)
            {
                DataRanges = Descriptor->DataRanges;
                Count = Descriptor->DataRangesCount;
            }
            else
            {
                DataRanges = Descriptor->ConstrainedDataRanges;
                Count = Descriptor->ConstrainedDataRangesCount;
            }
 
            for (Index = 0; Index < Count; Index++)
            {
                Size += ((DataRanges[Index]->FormatSize + 0x7) & ~0x7);
            }
 
            if (IoStack->Parameters.DeviceIoControl.OutputBufferLength == 0)
            {
                /* buffer too small */
                Irp->IoStatus.Information = Size;
                Status = STATUS_BUFFER_OVERFLOW;
                break;
            }
 
            Item = (KSMULTIPLE_ITEM*)Buffer;
 
            if (IoStack->Parameters.DeviceIoControl.OutputBufferLength == sizeof(ULONG))
            {
                /* store the result size */
                Item->Size = Size;
                Irp->IoStatus.Information = sizeof(ULONG);
                Status = STATUS_SUCCESS;
                break;
            }
 
            /* store descriptor size */
            Item->Size = Size;
            Item->Count = Count;
 
            if (IoStack->Parameters.DeviceIoControl.OutputBufferLength == sizeof(KSMULTIPLE_ITEM))
            {
                Irp->IoStatus.Information = sizeof(KSMULTIPLE_ITEM);
                Status = STATUS_SUCCESS;
                break;
            }
 
            /* now copy all dataranges */
            Data = (PUCHAR)(Item +1);
 
            /* alignment assert */
            ASSERT(((ULONG_PTR)Data & 0x7) == 0);
 
            for (Index = 0; Index < Count; Index++)
            {
                UNICODE_STRING GuidString;
                /* convert the guid to string */
                RtlStringFromGUID(&DataRanges[Index]->MajorFormat, &GuidString);
                DPRINT("Index %lu MajorFormat %S\n", Index, GuidString.Buffer);
                RtlStringFromGUID(&DataRanges[Index]->SubFormat, &GuidString);
                DPRINT("Index %lu SubFormat %S\n", Index, GuidString.Buffer);
                RtlStringFromGUID(&DataRanges[Index]->Specifier, &GuidString);
                DPRINT("Index %lu Specifier %S\n", Index, GuidString.Buffer);
                RtlStringFromGUID(&DataRanges[Index]->Specifier, &GuidString);
                DPRINT("Index %lu FormatSize %lu Flags %lu SampleSize %lu Reserved %lu KSDATAFORMAT %lu\n", Index,
                       DataRanges[Index]->FormatSize, DataRanges[Index]->Flags, DataRanges[Index]->SampleSize, DataRanges[Index]->Reserved, sizeof(KSDATAFORMAT));
 
                RtlMoveMemory(Data, DataRanges[Index], DataRanges[Index]->FormatSize);
                Data = ((PUCHAR)Data + DataRanges[Index]->FormatSize);
                /* alignment assert */
                ASSERT(((ULONG_PTR)Data & 0x7) == 0);
                Data = (PVOID)(((ULONG_PTR)Data + 0x7) & ~0x7);
            }
 
            Status = STATUS_SUCCESS;
            Irp->IoStatus.Information = Size;
            break;
        case KSPROPERTY_PIN_INTERFACES:
 
            if (Descriptor->Interfaces)
            {
                /* use mediums provided by driver */
                return KsHandleSizedListQuery(Irp, Descriptor->InterfacesCount, sizeof(KSPIN_MEDIUM), Descriptor->Interfaces);
            }
            else
            {
                /* use standard medium */
                return KsHandleSizedListQuery(Irp, 1, sizeof(KSPIN_INTERFACE), &StandardPinInterface);
            }
            break;
 
        case KSPROPERTY_PIN_MEDIUMS:
 
            if (Descriptor->MediumsCount)
            {
                /* use mediums provided by driver */
                return KsHandleSizedListQuery(Irp, Descriptor->MediumsCount, sizeof(KSPIN_MEDIUM), Descriptor->Mediums);
            }
            else
            {
                /* use standard medium */
                return KsHandleSizedListQuery(Irp, 1, sizeof(KSPIN_MEDIUM), &StandardPinMedium);
            }
            break;
 
        case KSPROPERTY_PIN_COMMUNICATION:
 
            Size = sizeof(KSPIN_COMMUNICATION);
            if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < Size)
            {
                Irp->IoStatus.Information = Size;
                Status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            *((KSPIN_COMMUNICATION*)Buffer) = Descriptor->Communication;
 
            Status = STATUS_SUCCESS;
            Irp->IoStatus.Information = Size;
            break;
 
        case KSPROPERTY_PIN_CATEGORY:
 
            if (!Descriptor->Category)
            {
                /* no pin category */
                return STATUS_NOT_FOUND;
            }
 
            /* check size */
            Size = sizeof(GUID);
            if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < Size)
            {
                /* buffer too small */
                Irp->IoStatus.Information = Size;
                Status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            /* copy category guid */
            RtlMoveMemory(Buffer, Descriptor->Category, sizeof(GUID));
 
            /* save result */
            Status = STATUS_SUCCESS;
            Irp->IoStatus.Information = Size;
            break;
 
        case KSPROPERTY_PIN_NAME:
 
            if (Descriptor->Name)
            {
                /* use pin name */
                Guid = (LPGUID)Descriptor->Name;
            }
            else
            {
                /* use pin category as fallback */
                Guid = (LPGUID)Descriptor->Category;
            }
 
            if (!Guid)
            {
                /* no friendly name available */
                return STATUS_NOT_FOUND;
            }
 
            /* read friendly name category name */
            Status = KspReadMediaCategory(Guid, &KeyInfo);
            if (!NT_SUCCESS(Status))
            {
                /* failed to read category */
                Irp->IoStatus.Information = 0;
                break;
            }
 
            /* store required length */
            Irp->IoStatus.Information = KeyInfo->DataLength + sizeof(WCHAR);
 
            /* check if buffer is too small */
            if (KeyInfo->DataLength + sizeof(WCHAR) > IoStack->Parameters.DeviceIoControl.OutputBufferLength)
            {
                /* buffer too small */
                Status = STATUS_BUFFER_OVERFLOW;
                FreeItem(KeyInfo);
                break;
            }
 
            /* copy result */
            RtlMoveMemory(Irp->AssociatedIrp.SystemBuffer, &KeyInfo->Data, KeyInfo->DataLength);
 
            /* null terminate name */
            ((LPWSTR)Irp->AssociatedIrp.SystemBuffer)[KeyInfo->DataLength / sizeof(WCHAR)] = L'\0';
 
            /* free key info */
            FreeItem(KeyInfo);
            break;
        case KSPROPERTY_PIN_PROPOSEDATAFORMAT:
            Size = sizeof(KSDATAFORMAT);
            if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < Size)
            {
                Irp->IoStatus.Information = Size;
                Status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
            if (IoStack->Parameters.DeviceIoControl.OutputBufferLength != sizeof(KSDATAFORMAT_WAVEFORMATEX))
            {
                UNIMPLEMENTED;
                Status = STATUS_NOT_IMPLEMENTED;
                Irp->IoStatus.Information = 0;
                break;
            }
 
            WaveFormatIn = (PKSDATAFORMAT_WAVEFORMATEX)Buffer;
            if (!Descriptor->DataRanges || !Descriptor->DataRangesCount)
            {
                Status = STATUS_UNSUCCESSFUL;
                Irp->IoStatus.Information = 0;
                break;
            }
            WaveFormatOut = (PKSDATARANGE_AUDIO*)Descriptor->DataRanges;
            for(Index = 0; Index < Descriptor->DataRangesCount; Index++)
            {
                if (WaveFormatOut[Index]->DataRange.FormatSize != sizeof(KSDATARANGE_AUDIO))
                {
                    UNIMPLEMENTED;
                    continue;
                }
 
                if (WaveFormatOut[Index]->MinimumSampleFrequency > WaveFormatIn->WaveFormatEx.nSamplesPerSec ||
                    WaveFormatOut[Index]->MaximumSampleFrequency < WaveFormatIn->WaveFormatEx.nSamplesPerSec ||
                    WaveFormatOut[Index]->MinimumBitsPerSample > WaveFormatIn->WaveFormatEx.wBitsPerSample ||
                    WaveFormatOut[Index]->MaximumBitsPerSample < WaveFormatIn->WaveFormatEx.wBitsPerSample ||
                    WaveFormatOut[Index]->MaximumChannels < WaveFormatIn->WaveFormatEx.nChannels)
                {
                    Irp->IoStatus.Status = STATUS_NO_MATCH;
                    Irp->IoStatus.Information = 0;
                    return STATUS_NO_MATCH;
                }
                else
                {
                    Irp->IoStatus.Status = STATUS_SUCCESS;
                    Irp->IoStatus.Information = 0;
                    return STATUS_SUCCESS;
                }
            }
            Status = STATUS_NO_MATCH;
            Irp->IoStatus.Information = 0;
            break;
        default:
            DPRINT1("Unhandled property request %x\n", Property->Id);
            Status = STATUS_NOT_IMPLEMENTED;
            Irp->IoStatus.Information = 0;
    }
 
    return Status;
}

Referenced by FilterPinPropertyHandler(), and KsPinPropertyHandler().

KspPropertyHandler()

NTSTATUS KspPropertyHandler	(	IN PIRP	Irp,
		IN ULONG	PropertySetsCount,
		IN const KSPROPERTY_SET *	PropertySet,
		IN PFNKSALLOCATOR Allocator	OPTIONAL,
		IN ULONG PropertyItemSize	OPTIONAL
	)

Definition at line 138 of file property.c.

{
    PKSPROPERTY Property;
    PKSPROPERTY_ITEM PropertyItem;
    PKSPROPERTY_SET Set;
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
    PFNKSHANDLER PropertyHandler = NULL;
    ULONG Index, InputBufferLength, OutputBufferLength, TotalSize;
    LPGUID Guid;
    //UNICODE_STRING GuidBuffer;
 
    /* get current irp stack */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* get parameters */
    OutputBufferLength = (IoStack->Parameters.DeviceIoControl.OutputBufferLength + 7) & ~7;
    InputBufferLength = IoStack->Parameters.DeviceIoControl.InputBufferLength;
 
    /* check for invalid buffer length size */
    if (OutputBufferLength < IoStack->Parameters.DeviceIoControl.OutputBufferLength)
    {
        /* unsigned overflow */
        return STATUS_INVALID_BUFFER_SIZE;
    }
 
    /* check for integer overflow */
    if (InputBufferLength + OutputBufferLength < IoStack->Parameters.DeviceIoControl.OutputBufferLength)
    {
        /* overflow */
        return STATUS_INVALID_BUFFER_SIZE;
    }
 
    /* check if inputbuffer at least holds KSPROPERTY item */
    if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(KSPROPERTY))
    {
        /* invalid parameter */
        return STATUS_INVALID_BUFFER_SIZE;
    }
 
    /* get total size */
    TotalSize = InputBufferLength + OutputBufferLength;
 
    /* get input property request */
    Property = (PKSPROPERTY)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
 
    /* have the parameters been checked yet */
    if (!Irp->AssociatedIrp.SystemBuffer)
    {
        /* is it from user mode */
        if (Irp->RequestorMode == UserMode)
        {
            /* probe user buffer */
            ProbeForRead(IoStack->Parameters.DeviceIoControl.Type3InputBuffer, InputBufferLength, 1);
        }
 
        /* do we have an allocator */
        if ((Allocator) && (Property->Flags & (KSPROPERTY_TYPE_GET | KSPROPERTY_TYPE_SET)))
        {
            /* call allocator */
            Status = Allocator(Irp, TotalSize, (Property->Flags & KSPROPERTY_TYPE_GET));
 
            /* check for success */
            if (!NT_SUCCESS(Status))
                return Status;
        }
        else
        {
            /* allocate buffer */
            Irp->AssociatedIrp.SystemBuffer = AllocateItem(NonPagedPool, TotalSize);
 
            /* sanity check */
            ASSERT(Irp->AssociatedIrp.SystemBuffer != NULL);
 
            /* mark irp as buffered so that changes the stream headers are propagated back */
            Irp->Flags |= IRP_DEALLOCATE_BUFFER | IRP_BUFFERED_IO;
        }
 
        /* now copy the buffer */
        RtlCopyMemory((PVOID)((ULONG_PTR)Irp->AssociatedIrp.SystemBuffer + OutputBufferLength), IoStack->Parameters.DeviceIoControl.Type3InputBuffer, InputBufferLength);
 
        /* use new property buffer */
        Property = (PKSPROPERTY)((ULONG_PTR)Irp->AssociatedIrp.SystemBuffer + OutputBufferLength);
 
        /* is it a set operation */
        if (Property->Flags & KSPROPERTY_TYPE_SET)
        {
            /* for set operations, the output parameters need to be copied */
            if (Irp->RequestorMode == UserMode)
            {
                /* probe user parameter */
                ProbeForRead(Irp->UserBuffer, IoStack->Parameters.DeviceIoControl.OutputBufferLength, 1);
            }
 
            /* copy parameters, needs un-aligned parameter length */
            RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, Irp->UserBuffer, IoStack->Parameters.DeviceIoControl.OutputBufferLength);
        }
 
        /* is there an output buffer */
        if (IoStack->Parameters.DeviceIoControl.OutputBufferLength)
        {
            /* is it from user mode */
            if (Irp->RequestorMode == UserMode)
            {
                /* probe buffer for writing */
                ProbeForWrite(Irp->UserBuffer, IoStack->Parameters.DeviceIoControl.OutputBufferLength, 1);
            }
 
            if (!Allocator || !(Property->Flags & KSPROPERTY_TYPE_GET))
            {
                /* it is an input operation */
                Irp->Flags |= IRP_INPUT_OPERATION;
            }
        }
    }
    else
    {
        /* use new property buffer */
        Property = (PKSPROPERTY)((ULONG_PTR)Irp->AssociatedIrp.SystemBuffer + OutputBufferLength);
    }
 
    //RtlStringFromGUID(&Property->Set, &GuidBuffer);
 
    //DPRINT("KspPropertyHandler Irp %p PropertySetsCount %u PropertySet %p Allocator %p PropertyItemSize %u ExpectedPropertyItemSize %u\n", Irp, PropertySetsCount, PropertySet, Allocator, PropertyItemSize, sizeof(KSPROPERTY_ITEM));
    //DPRINT("PropertyId %lu PropertyFlags %x Guid %S\n", Property->Id, Property->Flags, GuidBuffer.Buffer);
 
    //RtlFreeUnicodeString(&GuidBuffer);
 
    /* sanity check */
    ASSERT(PropertyItemSize == 0 || PropertyItemSize == sizeof(KSPROPERTY_ITEM));
 
    /* find the property handler */
    Status = FindPropertyHandler(&Irp->IoStatus, PropertySet, PropertySetsCount, Property, InputBufferLength, OutputBufferLength, Irp->AssociatedIrp.SystemBuffer, &PropertyHandler, &Set, &PropertyItem);
 
    if (NT_SUCCESS(Status) && PropertyHandler)
    {
        /* store set */
        KSPROPERTY_SET_IRP_STORAGE(Irp) = Set;
 
        /* are any custom property item sizes used */
        if (PropertyItemSize)
        {
            /* store custom property item */
            KSPROPERTY_ITEM_IRP_STORAGE(Irp) = PropertyItem;
        }
 
        _SEH2_TRY
        {
            /* call property handler */
            Status = PropertyHandler(Irp, Property, (OutputBufferLength > 0 ? Irp->AssociatedIrp.SystemBuffer : NULL));
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            _SEH2_YIELD(return _SEH2_GetExceptionCode());
        }
        _SEH2_END;
 
        if (Status == STATUS_BUFFER_TOO_SMALL)
        {
            /* output buffer is too small */
            if (Allocator)
            {
                /* allocate the requested amount */
                Status = Allocator(Irp, (ULONG)Irp->IoStatus.Information, FALSE);
 
                /* check if the block was allocated */
                if (!NT_SUCCESS(Status))
                {
                    /* no memory */
                    return STATUS_INSUFFICIENT_RESOURCES;
                }
                _SEH2_TRY
                {
                    /* re-call property handler */
                    Status = PropertyHandler(Irp, Property, Irp->AssociatedIrp.SystemBuffer);
                }
                _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
                {
                    Status =  _SEH2_GetExceptionCode();
                }
                _SEH2_END;
            }
        }
    }
    else if (IsEqualGUIDAligned(&Property->Set, &GUID_NULL) && Property->Id == 0 && (Property->Flags & KSPROPERTY_TYPE_SETSUPPORT) == KSPROPERTY_TYPE_SETSUPPORT)
    {
        // store output size
        Irp->IoStatus.Information = sizeof(GUID) * PropertySetsCount;
        if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(GUID) * PropertySetsCount)
        {
            // buffer too small
            return STATUS_MORE_ENTRIES;
        }
 
        // get output buffer
        Guid = (LPGUID)Irp->AssociatedIrp.SystemBuffer;
 
       // copy property guids from property sets
       for(Index = 0; Index < PropertySetsCount; Index++)
       {
           RtlMoveMemory(&Guid[Index], PropertySet[Index].Set, sizeof(GUID));
       }
       Status = STATUS_SUCCESS;
    }
 
    /* done */
    return Status;
}

Referenced by _IRQL_requires_max_(), IKsFilter_DispatchDeviceIoControl(), IKsPin_DispatchDeviceIoControl(), and KsPropertyHandler().

KspReadMediaCategory()

NTSTATUS KspReadMediaCategory	(	IN LPGUID	Category,
		PKEY_VALUE_PARTIAL_INFORMATION *	OutInformation
	)

Definition at line 232 of file connectivity.c.

{
    UNICODE_STRING MediaPath = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Control\\MediaCategories\\");
    UNICODE_STRING Name = RTL_CONSTANT_STRING(L"Name");
    UNICODE_STRING GuidString, Path;
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE hKey;
    ULONG Size;
    PKEY_VALUE_PARTIAL_INFORMATION KeyInfo;
 
    /* convert the guid to string */
    Status = RtlStringFromGUID(Category, &GuidString);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* allocate buffer for the registry key */
    Path.Length = 0;
    Path.MaximumLength = MediaPath.MaximumLength + GuidString.MaximumLength;
    Path.Buffer = AllocateItem(NonPagedPool, Path.MaximumLength);
    if (!Path.Buffer)
    {
        /* not enough memory */
        RtlFreeUnicodeString(&GuidString);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlAppendUnicodeStringToString(&Path, &MediaPath);
    RtlAppendUnicodeStringToString(&Path, &GuidString);
 
    /* free guid string */
    RtlFreeUnicodeString(&GuidString);
 
    /* initialize object attributes */
    InitializeObjectAttributes(&ObjectAttributes, &Path, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
 
    /* open the key */
    Status = ZwOpenKey(&hKey, GENERIC_READ, &ObjectAttributes);
 
    DPRINT("ZwOpenKey() status 0x%08lx %wZ\n", Status, &Path);
 
    /* free path buffer */
    FreeItem(Path.Buffer);
 
    /* check for success */
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ZwOpenKey() failed with status 0x%08lx\n", Status);
        return Status;
    }
 
    /* query the name size */
    Status = ZwQueryValueKey(hKey, &Name, KeyValuePartialInformation, NULL, 0, &Size);
    if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL)
    {
        /* failed to query for name key */
        ZwClose(hKey);
        return Status;
    }
 
    /* allocate buffer to read key info */
    KeyInfo = (PKEY_VALUE_PARTIAL_INFORMATION) AllocateItem(NonPagedPool, Size);
    if (!KeyInfo)
    {
        /* not enough memory */
        ZwClose(hKey);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* now read the info */
    Status = ZwQueryValueKey(hKey, &Name, KeyValuePartialInformation, (PVOID)KeyInfo, Size, &Size);
 
    /* close the key */
    ZwClose(hKey);
 
    if (!NT_SUCCESS(Status))
    {
        /* failed to read key */
        FreeItem(KeyInfo);
        return Status;
    }
 
    /* store key information */
    *OutInformation = KeyInfo;
    return Status;
}

Referenced by KspPinPropertyHandler(), and KsTopologyPropertyHandler().

KspRegisterDeviceInterfaces()

NTSTATUS KspRegisterDeviceInterfaces	(	IN PDEVICE_OBJECT	PhysicalDeviceObject,
		IN ULONG	CategoriesCount,
		IN GUID const *	Categories,
		IN PUNICODE_STRING	ReferenceString,
		OUT PLIST_ENTRY	SymbolicLinkList
	)

Definition at line 61 of file deviceinterface.c.

{
    ULONG Index;
    NTSTATUS Status = STATUS_SUCCESS;
    PSYMBOLIC_LINK_ENTRY SymEntry;
 
    for(Index = 0; Index < CategoriesCount; Index++)
    {
        /* allocate a symbolic link entry */
        SymEntry = AllocateItem(NonPagedPool, sizeof(SYMBOLIC_LINK_ENTRY));
        /* check for success */
        if (!SymEntry)
            return STATUS_INSUFFICIENT_RESOURCES;
 
        /* now register device interface */
        Status = IoRegisterDeviceInterface(PhysicalDeviceObject,
                                           &Categories[Index],
                                           ReferenceString,
                                           &SymEntry->SymbolicLink);
 
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Failed to register device interface %x\n", Status);
 
            /* free entry */
            FreeItem(SymEntry);
 
            /* return result */
            return Status;
        }
 
        /* copy device class */
        RtlMoveMemory(&SymEntry->DeviceInterfaceClass, &Categories[Index], sizeof(CLSID));
 
        /* insert symbolic link entry */
        InsertTailList(SymbolicLinkList, &SymEntry->Entry);
    }
 
    /* return result */
    return Status;
}

Referenced by IKsFilterFactory_fnInitialize().

KspSetDeviceInterfacesState()

NTSTATUS KspSetDeviceInterfacesState	(	IN PLIST_ENTRY	ListHead,
		IN BOOL	Enable
	)

Definition at line 7 of file deviceinterface.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PLIST_ENTRY Entry;
    PSYMBOLIC_LINK_ENTRY SymEntry;
 
 
    Entry = ListHead->Flink;
    while(Entry != ListHead)
    {
        /* fetch symbolic link entry */
        SymEntry = (PSYMBOLIC_LINK_ENTRY)CONTAINING_RECORD(Entry, SYMBOLIC_LINK_ENTRY, Entry);
        /* set device interface state */
        Status = IoSetDeviceInterfaceState(&SymEntry->SymbolicLink, Enable);
 
        DPRINT("KspSetDeviceInterfacesState SymbolicLink '%S' Status %lx\n", SymEntry->SymbolicLink.Buffer, Status, Enable);
 
        /* check for success */
        if (!NT_SUCCESS(Status))
            return Status;
        /* get next entry */
        Entry = Entry->Flink;
    }
    /* return result */
    return Status;
}

Referenced by IKsFilterFactory_fnRelease(), and IKsFilterFactory_fnSetDeviceClassesState().

KspSetFilterFactoriesState()

NTSTATUS KspSetFilterFactoriesState	(	IN PKSIDEVICE_HEADER	DeviceHeader,
		IN BOOLEAN	NewState
	)

Definition at line 109 of file deviceinterface.c.

{
    PCREATE_ITEM_ENTRY CreateEntry;
    PLIST_ENTRY Entry;
    NTSTATUS Status = STATUS_SUCCESS;
 
    /* grab first device interface */
    Entry = DeviceHeader->ItemList.Flink;
    while(Entry != &DeviceHeader->ItemList && Status == STATUS_SUCCESS)
    {
        /* grab create entry */
        CreateEntry = CONTAINING_RECORD(Entry, CREATE_ITEM_ENTRY, Entry);
 
        /* sanity check */
        ASSERT(CreateEntry->CreateItem);
 
        if (CreateEntry->CreateItem->Create == IKsFilterFactory_Create)
        {
            /* found our own filterfactory */
            Status = KsFilterFactorySetDeviceClassesState((PKSFILTERFACTORY)CreateEntry->CreateItem->Context, NewState);
        }
 
        Entry = Entry->Flink;
    }
 
    /* store result */
    return Status;
}

Referenced by IKsDevice_PnpPostStart(), and IKsDevice_PnpStartDevice().

KspValidateConnectRequest()

NTSTATUS KspValidateConnectRequest	(	IN PIRP	Irp,
		IN ULONG	DescriptorsCount,
		IN PVOID	Descriptors,
		IN ULONG	DescriptorSize,
		OUT PKSPIN_CONNECT *	Connect
	)

FIXME implement format checking

Definition at line 60 of file connectivity.c.

{
    PKSPIN_CONNECT ConnectDetails;
    PKSPIN_INTERFACE Interface;
    PKSPIN_MEDIUM Medium;
    ULONG Size;
    NTSTATUS Status;
    ULONG Index;
    ULONG Count;
    BOOLEAN Found;
    PKSPIN_DESCRIPTOR Descriptor;
    UNICODE_STRING GuidString2;
 
    /* did the caller miss the connect parameter */
    if (!Connect)
        return STATUS_INVALID_PARAMETER;
 
    /* set create param  size */
    Size = sizeof(KSPIN_CONNECT);
 
    /* fetch create parameters */
    Status = KspCopyCreateRequest(Irp,
                                  KSSTRING_Pin,
                                  &Size,
                                  (PVOID*)&ConnectDetails);
 
    /* check for success */
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* is pin id out of bounds */
    if (ConnectDetails->PinId >= DescriptorsCount)
    {
        FreeItem(ConnectDetails);
        return STATUS_INVALID_PARAMETER;
    }
 
    if (DescriptorSize == sizeof(KSPIN_DESCRIPTOR))
    {
        /* standard pin descriptor */
        Descriptor = (PKSPIN_DESCRIPTOR)((ULONG_PTR)Descriptors + sizeof(KSPIN_DESCRIPTOR) * ConnectDetails->PinId);
    }
    else
    {
        /* extended / variable pin descriptor */
        Descriptor = &((PKSPIN_DESCRIPTOR_EX)((ULONG_PTR)Descriptors + DescriptorSize * ConnectDetails->PinId))->PinDescriptor;
    }
 
 
    /* does the pin have interface details filled in */
    if (Descriptor->InterfacesCount && Descriptor->Interfaces)
    {
        /* use provided pin interface count */
        Count = Descriptor->InterfacesCount;
        Interface = (PKSPIN_INTERFACE)Descriptor->Interfaces;
    }
    else
    {
        /* use standard pin interface */
        Count = 1;
        Interface = &StandardPinInterface;
    }
 
    /* now check the interface */
    Found = FALSE;
    Index = 0;
    RtlStringFromGUID(&ConnectDetails->Interface.Set, &GuidString2);
    do
    {
        UNICODE_STRING GuidString;
        RtlStringFromGUID(&Interface[Index].Set, &GuidString);
 
        DPRINT("Driver Interface %S Id %u\n", GuidString.Buffer, Interface[Index].Id);
        DPRINT("Connect Interface %S Id %u\n", GuidString2.Buffer, ConnectDetails->Interface.Id);
 
        RtlFreeUnicodeString(&GuidString);
 
        if (IsEqualGUIDAligned(&Interface[Index].Set, &ConnectDetails->Interface.Set) &&
                               Interface[Index].Id == ConnectDetails->Interface.Id)
        {
            /* found a matching interface */
            Found = TRUE;
            break;
        }
        /* iterate to next interface */
        Index++;
    }while(Index < Count);
    RtlFreeUnicodeString(&GuidString2);
 
    if (!Found)
    {
        /* pin doesnt support this interface */
        FreeItem(ConnectDetails);
        return STATUS_NO_MATCH;
    }
 
    /* does the pin have medium details filled in */
    if (Descriptor->MediumsCount && Descriptor->Mediums)
    {
        /* use provided pin interface count */
        Count = Descriptor->MediumsCount;
        Medium = (PKSPIN_MEDIUM)Descriptor->Mediums;
    }
    else
    {
        /* use standard pin interface */
        Count = 1;
        Medium = &StandardPinMedium;
    }
 
    /* now check the interface */
    Found = FALSE;
    Index = 0;
    RtlStringFromGUID(&ConnectDetails->Medium.Set, &GuidString2);
    do
    {
        UNICODE_STRING GuidString;
        RtlStringFromGUID(&Medium[Index].Set, &GuidString);
 
        DPRINT("Driver Medium %S Id %u\n", GuidString.Buffer, Medium[Index].Id);
        DPRINT("Connect Medium %S Id %u\n", GuidString2.Buffer, ConnectDetails->Medium.Id);
 
        RtlFreeUnicodeString(&GuidString);
 
        if (IsEqualGUIDAligned(&Medium[Index].Set, &ConnectDetails->Medium.Set) &&
                               Medium[Index].Id == ConnectDetails->Medium.Id)
        {
            /* found a matching interface */
            Found = TRUE;
            break;
        }
 
        /* iterate to next medium */
        Index++;
    }while(Index < Count);
    RtlFreeUnicodeString(&GuidString2);
 
    if (!Found)
    {
        /* pin doesnt support this medium */
        FreeItem(ConnectDetails);
        return STATUS_NO_MATCH;
    }
 
 
    *Connect = ConnectDetails;
    return STATUS_SUCCESS;
}

Referenced by IKsFilter_DispatchCreatePin(), and KsValidateConnectRequest().