filter.c File Reference

#include "stream.h"

Include dependency graph for filter.c:

Go to the source code of this file.

Functions
NTSTATUS NTAPI	StreamClassCreatePin (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	FilterDispatch_fnDeviceIoControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	FilterDispatch_fnClose (PDEVICE_OBJECT DeviceObject, PIRP Irp)
VOID	RegisterDeviceInterfaces (IN PSTREAM_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	InitializeFilterWithKs (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	StreamClassCreateFilter (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)

Variables
static KSDISPATCH_TABLE	DispatchTable

Function Documentation

FilterDispatch_fnClose()

NTSTATUS NTAPI FilterDispatch_fnClose	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 45 of file filter.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PSTREAM_DEVICE_EXTENSION DeviceExtension;
    HW_STREAM_REQUEST_BLOCK_EXT RequestBlock;
 
   /* Get device extension */
    DeviceExtension = (PSTREAM_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    if (!DeviceExtension->DriverExtension->Data.FilterInstanceExtensionSize)
    {
        /* driver supports only one instance */
        if (DeviceExtension->InstanceCount)
        {
            /* there is already one instance open */
            return STATUS_UNSUCCESSFUL;
        }
    }
    else
    {
        /* driver supports more than one filter instance */
        RtlZeroMemory(&RequestBlock, sizeof(HW_STREAM_REQUEST_BLOCK_EXT));
 
        /* set up request block */
        RequestBlock.Block.Command = SRB_CLOSE_DEVICE_INSTANCE;
        RequestBlock.Block.HwDeviceExtension = DeviceExtension->DeviceExtension;
        RequestBlock.Block.Irp = Irp;
        KeInitializeEvent(&RequestBlock.Event, SynchronizationEvent, FALSE);
 
        /*FIXME SYNCHRONIZATION */
 
        /* Send the request */
        DeviceExtension->DriverExtension->Data.HwReceivePacket((PHW_STREAM_REQUEST_BLOCK)&RequestBlock);
        if (RequestBlock.Block.Status == STATUS_PENDING)
        {
            /* Wait for the request */
            KeWaitForSingleObject(&RequestBlock.Event, Executive, KernelMode, FALSE, NULL);
        }
    }
 
    /* Increment total instance count */
    InterlockedDecrement(&DeviceExtension->InstanceCount);
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return Status;
}

FilterDispatch_fnDeviceIoControl()

NTSTATUS NTAPI FilterDispatch_fnDeviceIoControl	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 30 of file filter.c.

{
    DPRINT1("FilterDispatch Called\n");
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}

InitializeFilterWithKs()

NTSTATUS InitializeFilterWithKs	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 150 of file filter.c.

{
    NTSTATUS Status;
    PSTREAM_DEVICE_EXTENSION DeviceExtension;
    KSOBJECT_HEADER ObjectHeader;
    PKSOBJECT_CREATE_ITEM CreateItem;
    PIO_STACK_LOCATION IoStack;
    HW_STREAM_REQUEST_BLOCK_EXT RequestBlock;
    PVOID HwInstanceExtension = NULL;
 
   /* Get device extension */
    DeviceExtension = (PSTREAM_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    if (!DeviceExtension->DriverExtension->Data.FilterInstanceExtensionSize)
    {
        /* driver supports only one instance */
        if (DeviceExtension->InstanceCount)
        {
            /* there is already one instance open */
            return STATUS_UNSUCCESSFUL;
        }
    }
    else
    {
        /* driver supports more than one filter instance */
        RtlZeroMemory(&RequestBlock, sizeof(HW_STREAM_REQUEST_BLOCK_EXT));
 
        /* allocate instance extension */
        HwInstanceExtension = ExAllocatePool(NonPagedPool, DeviceExtension->DriverExtension->Data.FilterInstanceExtensionSize);
        if (!HwInstanceExtension)
        {
            /* Not enough memory */
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        /* Zero instance extension */
        RtlZeroMemory(HwInstanceExtension, DeviceExtension->DriverExtension->Data.FilterInstanceExtensionSize);
 
        /* set up request block */
        RequestBlock.Block.Command = SRB_OPEN_DEVICE_INSTANCE;
        RequestBlock.Block.HwDeviceExtension = DeviceExtension->DeviceExtension;
        RequestBlock.Block.Irp = Irp;
        RequestBlock.Block.HwInstanceExtension = HwInstanceExtension;
        KeInitializeEvent(&RequestBlock.Event, SynchronizationEvent, FALSE);
 
        /*FIXME SYNCHRONIZATION */
 
        /* Send the request */
        DeviceExtension->DriverExtension->Data.HwReceivePacket((PHW_STREAM_REQUEST_BLOCK)&RequestBlock);
        if (RequestBlock.Block.Status == STATUS_PENDING)
        {
            /* Wait for the request */
            KeWaitForSingleObject(&RequestBlock.Event, Executive, KernelMode, FALSE, NULL);
        }
        /* Check for success */
        if (!NT_SUCCESS(RequestBlock.Block.Status))
        {
            /* Resource is not available */
            ExFreePool(HwInstanceExtension);
            return RequestBlock.Block.Status;
        }
    }
 
    /* Allocate create item */
    CreateItem = ExAllocatePool(NonPagedPool, sizeof(KSOBJECT_CREATE_ITEM));
    if (!CreateItem)
    {
        /* not enough memory */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Zero create item */
    RtlZeroMemory(CreateItem, sizeof(KSOBJECT_CREATE_ITEM));
    /* Initialize createitem */
    RtlInitUnicodeString(&CreateItem->ObjectClass, KSSTRING_Pin);
    CreateItem->Create = StreamClassCreatePin;
 
    /* Get current irp stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    /* Create Ks streaming object header */
    Status = KsAllocateObjectHeader(&ObjectHeader, 1, CreateItem, Irp, &DispatchTable);
    if (!NT_SUCCESS(Status))
    {
        /* Failed to create header */
        ExFreePool(CreateItem);
        if (HwInstanceExtension)
        {
            /* free instance buffer */
            ExFreePool(HwInstanceExtension);
        }
        return Status;
    }
 
    /* Store instance buffer in file object context */
    IoStack->FileObject->FsContext2 = HwInstanceExtension;
 
    /* Increment total instance count */
    InterlockedIncrement(&DeviceExtension->InstanceCount);
 
    /* Register device stream interfaces */
    RegisterDeviceInterfaces(DeviceExtension);
 
    /* Return result */
    return Status;
 
}

Referenced by StreamClassCreateFilter().

RegisterDeviceInterfaces()

VOID RegisterDeviceInterfaces

(

IN PSTREAM_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 111 of file filter.c.

{
    ULONG Index;
    PHW_STREAM_INFORMATION StreamInformation;
    UNICODE_STRING SymbolicLink;
    NTSTATUS Status;
 
    /* Sanity check */
    ASSERT(DeviceExtension->StreamDescriptor);
    ASSERT(DeviceExtension->StreamDescriptorSize);
 
    /* Loop all stream descriptors and register device interfaces */
    StreamInformation = (PHW_STREAM_INFORMATION)&DeviceExtension->StreamDescriptor->StreamInfo;
 
    for(Index = 0; DeviceExtension->StreamDescriptor->StreamHeader.NumberOfStreams; Index++)
    {
        if (StreamInformation->Category)
        {
            /* Register device interface */
            Status = IoRegisterDeviceInterface(DeviceExtension->PhysicalDeviceObject,
                                               StreamInformation->Category,
                                               NULL, /* see CORE-4218 and r42457 */
                                               &SymbolicLink);
 
            if (NT_SUCCESS(Status))
            {
                /* Activate device interface */
                IoSetDeviceInterfaceState(&SymbolicLink, TRUE);
                /* Release Symbolic Link */
                RtlFreeUnicodeString(&SymbolicLink);
            }
        }
        StreamInformation = (PHW_STREAM_INFORMATION) (ULONG_PTR)StreamInformation + DeviceExtension->StreamDescriptor->StreamHeader.SizeOfHwStreamInformation;
    }
 
}

Referenced by InitializeFilterWithKs().

StreamClassCreateFilter()

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

Definition at line 261 of file filter.c.

{
    NTSTATUS Status;
    DPRINT1("StreamClassCreateFilter Called\n");
 
    /* Init filter */
    Status = InitializeFilterWithKs(DeviceObject, Irp);
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return Status;
}

Referenced by StreamClassAddDevice().

StreamClassCreatePin()

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

Definition at line 15 of file filter.c.

{
    UNIMPLEMENTED;
 
    Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by InitializeFilterWithKs().

Variable Documentation

DispatchTable

KSDISPATCH_TABLE DispatchTable

static

Initial value:

=
{
    FilterDispatch_fnDeviceIoControl,
    KsDispatchInvalidDeviceRequest,
    KsDispatchInvalidDeviceRequest,
    KsDispatchInvalidDeviceRequest,
    FilterDispatch_fnClose,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
}

Definition at line 96 of file filter.c.