Messaging.c File Reference

#include "fltmgr.h"
#include "fltmgrint.h"
#include <fltmgr_shared.h>
#include <debug.h>

Include dependency graph for Messaging.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
static BOOLEAN	FltpDisconnectPort (_In_ PFLT_PORT_OBJECT PortObject)
static NTSTATUS	CreateClientPort (_In_ PFILE_OBJECT FileObject, _Inout_ PIRP Irp)
static NTSTATUS	CloseClientPort (_In_ PFILE_OBJECT FileObject, _Inout_ PIRP Irp)
static NTSTATUS	InitializeMessageWaiterQueue (_Inout_ PFLT_MESSAGE_WAITER_QUEUE MsgWaiterQueue)
static PPORT_CCB	CreatePortCCB (_In_ PFLT_PORT_OBJECT PortObject)
_Must_inspect_result_	_IRQL_requires_max_ (PASSIVE_LEVEL)
_Must_inspect_result_	_IRQL_requires_max_ (APC_LEVEL)
NTSTATUS	FltpMsgCreate (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
NTSTATUS	FltpMsgDispatch (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
VOID NTAPI	FltpServerPortClose (_In_opt_ PEPROCESS Process, _In_ PVOID Object, _In_ ACCESS_MASK GrantedAccess, _In_ ULONG ProcessHandleCount, _In_ ULONG SystemHandleCount)
VOID NTAPI	FltpServerPortDelete (PVOID Object)
VOID NTAPI	FltpClientPortClose (_In_opt_ PEPROCESS Process, _In_ PVOID Object, _In_ ACCESS_MASK GrantedAccess, _In_ ULONG ProcessHandleCount, _In_ ULONG SystemHandleCount)
VOID NTAPI	FltpClientPortDelete (PVOID Object)
NTSTATUS	FltpSetupCommunicationObjects (_In_ PDRIVER_OBJECT DriverObject)
NTSTATUS NTAPI	FltpAddMessageWaiter (_In_ PIO_CSQ Csq, _In_ PIRP Irp, _In_ PVOID InsertContext)
VOID NTAPI	FltpRemoveMessageWaiter (_In_ PIO_CSQ Csq, _In_ PIRP Irp)
PIRP NTAPI	FltpGetNextMessageWaiter (_In_ PIO_CSQ Csq, _In_ PIRP Irp, _In_ PVOID PeekContext)
	_Acquires_lock_ (((PFLT_MESSAGE_WAITER_QUEUE) CONTAINING_RECORD(Csq, FLT_MESSAGE_WAITER_QUEUE, Csq)) ->WaiterQ.mLock) _IRQL_saves_global_(Irql
PFLT_MESSAGE_WAITER_QUEUE	CONTAINING_RECORD (Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
	_Releases_lock_ (((PFLT_MESSAGE_WAITER_QUEUE) CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) ->WaiterQ.mLock) _IRQL_restores_global_(Irql
VOID NTAPI	FltpCancelMessageWaiter (_In_ PIO_CSQ Csq, _In_ PIRP Irp)

Variables
UNICODE_STRING	CommsDeviceName = RTL_CONSTANT_STRING(L"\\FileSystem\\Filters\\FltMgrMsg")
PDEVICE_OBJECT	CommsDeviceObject
POBJECT_TYPE	ServerPortObjectType
POBJECT_TYPE	ClientPortObjectType

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 15 of file Messaging.c.

Function Documentation

_Acquires_lock_()

_Acquires_lock_

(

((PFLT_MESSAGE_WAITER_QUEUE) CONTAINING_RECORD(Csq, FLT_MESSAGE_WAITER_QUEUE, Csq)) ->WaiterQ.

mLock

)

_IRQL_requires_max_() [1/2]

_Must_inspect_result_ _IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 198 of file Messaging.c.

{
    UNREFERENCED_PARAMETER(Filter);
    UNREFERENCED_PARAMETER(ClientPort);
    UNREFERENCED_PARAMETER(SenderBuffer);
    UNREFERENCED_PARAMETER(SenderBufferLength);
    UNREFERENCED_PARAMETER(ReplyBuffer);
    UNREFERENCED_PARAMETER(ReplyLength);
    UNREFERENCED_PARAMETER(Timeout);
    return STATUS_NOT_IMPLEMENTED;
}

_IRQL_requires_max_() [2/2]

_Must_inspect_result_ _IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 64 of file Messaging.c.

{
    PFLT_SERVER_PORT_OBJECT PortObject;
    NTSTATUS Status;
 
    /* The caller must allow at least one connection */
    if (MaxConnections == 0)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* The request must be for a kernel handle */
    if (!(ObjectAttributes->Attributes & OBJ_KERNEL_HANDLE))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /*
     * Get rundown protection on the target to stop the owner
     * from unloading whilst this port object is open. It gets
     * removed in the FltpServerPortClose callback
     */
    Status = FltObjectReference(Filter);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Create the server port object for this filter */
    Status = ObCreateObject(KernelMode,
                            ServerPortObjectType,
                            ObjectAttributes,
                            KernelMode,
                            NULL,
                            sizeof(FLT_SERVER_PORT_OBJECT),
                            0,
                            0,
                            (PVOID *)&PortObject);
    if (NT_SUCCESS(Status))
    {
        /* Zero out the struct */
        RtlZeroMemory(PortObject, sizeof(FLT_SERVER_PORT_OBJECT));
 
        /* Increment the ref count on the target filter */
        FltpObjectPointerReference((PFLT_OBJECT)Filter);
 
        /* Setup the filter port object */
        PortObject->Filter = Filter;
        PortObject->ConnectNotify = ConnectNotifyCallback;
        PortObject->DisconnectNotify = DisconnectNotifyCallback;
        PortObject->MessageNotify = MessageNotifyCallback;
        PortObject->Cookie = ServerPortCookie;
        PortObject->MaxConnections = MaxConnections;
 
        /* Insert the object */
        Status = ObInsertObject(PortObject,
                                NULL,
                                STANDARD_RIGHTS_ALL | FILE_READ_DATA,
                                0,
                                NULL,
                                (PHANDLE)ServerPort);
        if (NT_SUCCESS(Status))
        {
            /* Lock the connection list */
            ExAcquireFastMutex(&Filter->ConnectionList.mLock);
 
            /* Add the new port object to the connection list and increment the count */
            InsertTailList(&Filter->ConnectionList.mList, &PortObject->FilterLink);
            Filter->ConnectionList.mCount++;
 
            /* Unlock the connection list*/
            ExReleaseFastMutex(&Filter->ConnectionList.mLock);
        }
    }
 
    if (!NT_SUCCESS(Status))
    {
        /* Allow the filter to be cleaned up */
        FltObjectDereference(Filter);
    }
 
    return Status;
}

_Releases_lock_()

_Releases_lock_

(

((PFLT_MESSAGE_WAITER_QUEUE) CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) ->WaiterQ.

mLock

)

CloseClientPort()

static NTSTATUS CloseClientPort ( _In_ PFILE_OBJECT  FileObject, _Inout_ PIRP  Irp  )

static

Definition at line 766 of file Messaging.c.

{
    PFLT_CCB Ccb;
 
    Ccb = (PFLT_CCB)FileObject->FsContext2;
 
    /* Remove the reference on the filter we added when we opened the port */
    ObDereferenceObject(Ccb->Data.Port.Port);
 
    // FIXME: Free the CCB
 
    return STATUS_SUCCESS;
}

Referenced by FltpMsgDispatch().

CONTAINING_RECORD()

PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD	(	Csq	,
		DEVICE_EXTENSION	,
		IrpQueue
	)		-> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)

Definition at line 560 of file Messaging.c.

{
    PFLT_MESSAGE_WAITER_QUEUE MessageWaiterQueue;
 
    UNREFERENCED_PARAMETER(Irql);
 
    /* Get the start of the waiter queue struct */
    MessageWaiterQueue = CONTAINING_RECORD(Csq,
                                           FLT_MESSAGE_WAITER_QUEUE,
                                           Csq);
 
    /* Acquire the IRP queue lock */
    ExAcquireFastMutex(&MessageWaiterQueue->WaiterQ.mLock);
}

CreateClientPort()

static NTSTATUS CreateClientPort ( _In_ PFILE_OBJECT  FileObject, _Inout_ PIRP  Irp  )

static

Definition at line 617 of file Messaging.c.

{
    PFLT_SERVER_PORT_OBJECT ServerPortObject = NULL;
    OBJECT_ATTRIBUTES ObjectAttributes;
    PFILTER_PORT_DATA FilterPortData;
    PFLT_PORT_OBJECT ClientPortObject = NULL;
    PFLT_PORT PortHandle = NULL;
    PPORT_CCB PortCCB = NULL;
    //ULONG BufferLength;
    LONG NumConns;
    NTSTATUS Status;
 
    /* We received the buffer via FilterConnectCommunicationPort, cast it back to its original form */
    FilterPortData = Irp->AssociatedIrp.SystemBuffer;
 
    /* Get a reference to the server port the filter created */
    Status = ObReferenceObjectByName(&FilterPortData->PortName,
                                     0,
                                     0,
                                     FLT_PORT_ALL_ACCESS,
                                     ServerPortObjectType,
                                     ExGetPreviousMode(),
                                     0,
                                     (PVOID *)&ServerPortObject);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Increment the number of connections on the server port */
    NumConns = InterlockedIncrement(&ServerPortObject->NumberOfConnections);
    if (NumConns > ServerPortObject->MaxConnections)
    {
        Status = STATUS_CONNECTION_COUNT_LIMIT;
        goto Quit;
    }
 
    /* Initialize a basic kernel handle request */
    InitializeObjectAttributes(&ObjectAttributes,
                               NULL,
                               OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
 
    /* Now create the new client port object */
    Status = ObCreateObject(KernelMode,
                            ClientPortObjectType,
                            &ObjectAttributes,
                            KernelMode,
                            NULL,
                            sizeof(FLT_PORT_OBJECT),
                            0,
                            0,
                            (PVOID *)&ClientPortObject);
    if (!NT_SUCCESS(Status))
    {
        goto Quit;
    }
 
    /* Clear out the buffer */
    RtlZeroMemory(ClientPortObject, sizeof(FLT_PORT_OBJECT));
 
    /* Initialize the locks */
    ExInitializeRundownProtection(&ClientPortObject->MsgNotifRundownRef);
    ExInitializeFastMutex(&ClientPortObject->Lock);
 
    /* Set the server port object this belongs to */
    ClientPortObject->ServerPort = ServerPortObject;
 
    /* Setup the message queue */
    Status = InitializeMessageWaiterQueue(&ClientPortObject->MsgQ);
    if (!NT_SUCCESS(Status))
    {
        goto Quit;
    }
 
    /* Create the CCB which we'll attach to the file object */
    PortCCB = CreatePortCCB(ClientPortObject);
    if (PortCCB == NULL)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Quit;
    }
 
    /* Now insert the new client port into the object manager */
    Status = ObInsertObject(ClientPortObject, NULL, FLT_PORT_ALL_ACCESS, 1, NULL, (PHANDLE)&PortHandle);
    if (!NT_SUCCESS(Status))
    {
        /* ObInsertObject() failed and already dereferenced ClientPortObject */
        ClientPortObject = NULL;
        goto Quit;
    }
 
    /* Add a reference to the filter to keep it alive while we do some work with it */
    Status = FltObjectReference(ServerPortObject->Filter);
    if (NT_SUCCESS(Status))
    {
        /* Invoke the callback to let the filter know we have a connection */
        Status = ServerPortObject->ConnectNotify(PortHandle,
                                                 ServerPortObject->Cookie,
                                                 NULL, //ConnectionContext
                                                 0, //SizeOfContext
                                                 &ClientPortObject->Cookie);
        if (NT_SUCCESS(Status))
        {
            /* Add the client port CCB to the file object */
            FileObject->FsContext2 = PortCCB;
 
            /* Lock the port list on the filter and add this new port object to the list */
            ExAcquireFastMutex(&ServerPortObject->Filter->PortList.mLock);
            InsertTailList(&ServerPortObject->Filter->PortList.mList, &ClientPortObject->FilterLink);
            ExReleaseFastMutex(&ServerPortObject->Filter->PortList.mLock);
        }
 
        /* We're done with the filter object, decremement the count */
        FltObjectDereference(ServerPortObject->Filter);
    }
 
 
Quit:
    if (!NT_SUCCESS(Status))
    {
        if (ClientPortObject)
        {
            ObDereferenceObject(ClientPortObject);
        }
 
        if (PortHandle)
        {
            ZwClose(PortHandle);
        }
        else if (ServerPortObject)
        {
            InterlockedDecrement(&ServerPortObject->NumberOfConnections);
            ObDereferenceObject(ServerPortObject);
        }
 
        if (PortCCB)
        {
            ExFreePoolWithTag(PortCCB, FM_TAG_CCB);
        }
    }
 
    return Status;
}

Referenced by FltpMsgCreate().

CreatePortCCB()

static PPORT_CCB CreatePortCCB ( _In_ PFLT_PORT_OBJECT  PortObject )

static

Definition at line 817 of file Messaging.c.

{
    PPORT_CCB PortCCB;
 
    /* Allocate a CCB struct to hold the client port object info */
    PortCCB = ExAllocatePoolWithTag(NonPagedPool, sizeof(PORT_CCB), FM_TAG_CCB);
    if (PortCCB)
    {
        /* Initialize the structure */
        PortCCB->Port = PortObject;
        PortCCB->ReplyWaiterList.mCount = 0;
        ExInitializeFastMutex(&PortCCB->ReplyWaiterList.mLock);
        KeInitializeEvent(&PortCCB->ReplyWaiterList.mLock.Event, SynchronizationEvent, 0);
    }
 
    return PortCCB;
}

Referenced by CreateClientPort().

FltpAddMessageWaiter()

NTSTATUS NTAPI FltpAddMessageWaiter	(	_In_ PIO_CSQ	Csq,
		_In_ PIRP	Irp,
		_In_ PVOID	InsertContext
	)

Definition at line 470 of file Messaging.c.

{
    PFLT_MESSAGE_WAITER_QUEUE MessageWaiterQueue;
 
    /* Get the start of the waiter queue struct */
    MessageWaiterQueue = CONTAINING_RECORD(Csq,
                                           FLT_MESSAGE_WAITER_QUEUE,
                                           Csq);
 
    /* Insert the IRP at the end of the queue */
    InsertTailList(&MessageWaiterQueue->WaiterQ.mList,
                   &Irp->Tail.Overlay.ListEntry);
 
    /* return success */
    return STATUS_SUCCESS;
}

Referenced by InitializeMessageWaiterQueue().

FltpCancelMessageWaiter()

VOID NTAPI FltpCancelMessageWaiter	(	_In_ PIO_CSQ	Csq,
		_In_ PIRP	Irp
	)

Definition at line 603 of file Messaging.c.

{
    /* Cancel the IRP */
    Irp->IoStatus.Status = STATUS_CANCELLED;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}

Referenced by InitializeMessageWaiterQueue().

FltpClientPortClose()

VOID NTAPI FltpClientPortClose	(	_In_opt_ PEPROCESS	Process,
		_In_ PVOID	Object,
		_In_ ACCESS_MASK	GrantedAccess,
		_In_ ULONG	ProcessHandleCount,
		_In_ ULONG	SystemHandleCount
	)

Definition at line 327 of file Messaging.c.

{
    PFLT_PORT_OBJECT PortObject = (PFLT_PORT_OBJECT)Object;
 
    if (FltpDisconnectPort(PortObject))
    {
        InterlockedDecrement(&PortObject->ServerPort->NumberOfConnections);
    }
}

Referenced by FltpSetupCommunicationObjects().

FltpClientPortDelete()

VOID NTAPI FltpClientPortDelete

(

PVOID

Object

)

Definition at line 369 of file Messaging.c.

{
    PFLT_PORT_OBJECT PortObject = (PFLT_PORT_OBJECT)Object;
    ObDereferenceObject(PortObject->ServerPort);
}

Referenced by FltpSetupCommunicationObjects().

FltpDisconnectPort()

BOOLEAN FltpDisconnectPort ( _In_ PFLT_PORT_OBJECT  PortObject )

static

Definition at line 342 of file Messaging.c.

{
    BOOLEAN Disconnected = FALSE;
 
    /* Lock the port object while we disconnect it */
    ExAcquireFastMutex(&PortObject->Lock);
 
    /* Make sure we have a valid connection */
    if (PortObject->Disconnected == FALSE)
    {
        /* Let any waiters know we're dusconnecing */
        KeSetEvent(&PortObject->DisconnectEvent, 0, 0);
 
        // cleanup everything in the message queue (PortObject->MsgQ.Csq)
 
        /* Set the disconnected state to true */
        PortObject->Disconnected = TRUE;
        Disconnected = TRUE;
    }
 
    /* Unlock and exit*/
    ExReleaseFastMutex(&PortObject->Lock);
    return Disconnected;
}

Referenced by FltpClientPortClose().

FltpGetNextMessageWaiter()

PIRP NTAPI FltpGetNextMessageWaiter	(	_In_ PIO_CSQ	Csq,
		_In_ PIRP	Irp,
		_In_ PVOID	PeekContext
	)

Definition at line 500 of file Messaging.c.

{
    PFLT_MESSAGE_WAITER_QUEUE MessageWaiterQueue;
    PIRP NextIrp = NULL;
    PLIST_ENTRY NextEntry;
    PIO_STACK_LOCATION IrpStack;
 
    /* Get the start of the waiter queue struct */
    MessageWaiterQueue = CONTAINING_RECORD(Csq,
                                           FLT_MESSAGE_WAITER_QUEUE,
                                           Csq);
 
    /* Is the IRP valid? */
    if (Irp == NULL)
    {
        /* Start peeking from the listhead */
        NextEntry = MessageWaiterQueue->WaiterQ.mList.Flink;
    }
    else
    {
        /* Start peeking from that IRP onwards */
        NextEntry = Irp->Tail.Overlay.ListEntry.Flink;
    }
 
    /* Loop through the queue */
    while (NextEntry != &MessageWaiterQueue->WaiterQ.mList)
    {
        /* Store the next IRP in the list */
        NextIrp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
 
        /* Did we supply a PeekContext on insert? */
        if (!PeekContext)
        {
            /* We already have the next IRP */
            break;
        }
        else
        {
            /* Get the stack of the next IRP */
            IrpStack = IoGetCurrentIrpStackLocation(NextIrp);
 
            /* Does the PeekContext match the object? */
            if (IrpStack->FileObject == (PFILE_OBJECT)PeekContext)
            {
                /* We have a match */
                break;
            }
 
            /* Move to the next IRP */
            NextIrp = NULL;
            NextEntry = NextEntry->Flink;
        }
    }
 
    return NextIrp;
}

Referenced by InitializeMessageWaiterQueue().

FltpMsgCreate()

NTSTATUS FltpMsgCreate	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp
	)

Definition at line 223 of file Messaging.c.

{
    PIO_STACK_LOCATION StackPtr;
    NTSTATUS Status;
 
    /* Get the stack location */
    StackPtr = IoGetCurrentIrpStackLocation(Irp);
 
    FLT_ASSERT(StackPtr->MajorFunction == IRP_MJ_CREATE);
 
    /* Check if this is a caller wanting to connect */
    if (StackPtr->MajorFunction == IRP_MJ_CREATE)
    {
        /* Create the client port for this connection and exit */
        Status = CreateClientPort(StackPtr->FileObject, Irp);
    }
    else
    {
        Status = STATUS_INVALID_PARAMETER;
    }
 
    if (Status != STATUS_PENDING)
    {
        Irp->IoStatus.Status = Status;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, 0);
    }
 
    return Status;
}

Referenced by FltpCreate().

FltpMsgDispatch()

NTSTATUS FltpMsgDispatch	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp
	)

Definition at line 256 of file Messaging.c.

{
    PIO_STACK_LOCATION StackPtr;
    NTSTATUS Status;
 
    /* Get the stack location */
    StackPtr = IoGetCurrentIrpStackLocation(Irp);
 
    /* Check if this is a caller wanting to connect */
    if (StackPtr->MajorFunction == IRP_MJ_CLOSE)
    {
        /* Create the client port for this connection and exit */
        Status = CloseClientPort(StackPtr->FileObject, Irp);
    }
    else
    {
        // We don't support anything else yet
        Status = STATUS_NOT_IMPLEMENTED;
    }
 
    if (Status != STATUS_PENDING)
    {
        Irp->IoStatus.Status = Status;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, 0);
    }
 
    return Status;
}

Referenced by FltpDispatch().

FltpRemoveMessageWaiter()

VOID NTAPI FltpRemoveMessageWaiter	(	_In_ PIO_CSQ	Csq,
		_In_ PIRP	Irp
	)

Definition at line 491 of file Messaging.c.

{
    /* Remove the IRP from the queue */
    RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
}

Referenced by InitializeMessageWaiterQueue().

FltpServerPortClose()

VOID NTAPI FltpServerPortClose	(	_In_opt_ PEPROCESS	Process,
		_In_ PVOID	Object,
		_In_ ACCESS_MASK	GrantedAccess,
		_In_ ULONG	ProcessHandleCount,
		_In_ ULONG	SystemHandleCount
	)

Definition at line 289 of file Messaging.c.

{
    PFLT_SERVER_PORT_OBJECT PortObject;
    PFAST_MUTEX Lock;
 
    /* Cast the object to a server port object */
    PortObject = (PFLT_SERVER_PORT_OBJECT)Object;
 
    /* Lock the connection list */
    Lock = &PortObject->Filter->ConnectionList.mLock;
    ExAcquireFastMutex(Lock);
 
    /* Remove the server port object from the list */
    RemoveEntryList(&PortObject->FilterLink);
 
    /* Unlock the connection list */
    ExReleaseFastMutex(Lock);
 
    /* Remove the rundown protection we added to stop the owner from tearing us down */
    FltObjectDereference(PortObject->Filter);
}

Referenced by FltpSetupCommunicationObjects().

FltpServerPortDelete()

VOID NTAPI FltpServerPortDelete

(

PVOID

Object

)

Definition at line 317 of file Messaging.c.

{
    /* Decrement the filter count we added in the create routine */
    PFLT_SERVER_PORT_OBJECT PortObject = (PFLT_SERVER_PORT_OBJECT)Object;
    FltpObjectPointerDereference((PFLT_OBJECT)PortObject->Filter);
 
}

Referenced by FltpSetupCommunicationObjects().

FltpSetupCommunicationObjects()

NTSTATUS FltpSetupCommunicationObjects

(

_In_ PDRIVER_OBJECT

DriverObject

)

Definition at line 377 of file Messaging.c.

{
    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
    UNICODE_STRING SymLinkName;
    UNICODE_STRING Name;
    NTSTATUS Status;
 
    GENERIC_MAPPING Mapping =
    {
        STANDARD_RIGHTS_READ,
        STANDARD_RIGHTS_WRITE,
        STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE,
        FLT_PORT_ALL_ACCESS
    };
 
    /* Create the server comms object type */
    RtlZeroMemory(&ObjectTypeInitializer, sizeof(OBJECT_TYPE_INITIALIZER));
    RtlInitUnicodeString(&Name, L"FilterConnectionPort");
    ObjectTypeInitializer.Length = sizeof(OBJECT_TYPE_INITIALIZER);
    ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
    ObjectTypeInitializer.GenericMapping = Mapping;
    ObjectTypeInitializer.PoolType = NonPagedPool;
    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(FLT_SERVER_PORT_OBJECT);
    ObjectTypeInitializer.ValidAccessMask = GENERIC_ALL;
    ObjectTypeInitializer.CloseProcedure = FltpServerPortClose;
    ObjectTypeInitializer.DeleteProcedure = FltpServerPortDelete;
    Status = ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ServerPortObjectType);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Create the client comms object type */
    RtlZeroMemory(&ObjectTypeInitializer, sizeof(OBJECT_TYPE_INITIALIZER));
    RtlInitUnicodeString(&Name, L"FilterCommunicationPort");
    ObjectTypeInitializer.Length = sizeof(OBJECT_TYPE_INITIALIZER);
    ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
    ObjectTypeInitializer.GenericMapping = Mapping;
    ObjectTypeInitializer.PoolType = NonPagedPool;
    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(FLT_PORT_OBJECT);
    ObjectTypeInitializer.ValidAccessMask = GENERIC_ALL;
    ObjectTypeInitializer.CloseProcedure = FltpClientPortClose;
    ObjectTypeInitializer.DeleteProcedure = FltpClientPortDelete;
    Status = ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ClientPortObjectType);
    if (!NT_SUCCESS(Status))
    {
        goto Quit;
    }
 
    /* Create the device object */
    Status = IoCreateDevice(DriverObject,
                            0,
                            &CommsDeviceName,
                            FILE_DEVICE_WPD,
                            0,
                            0,
                            &CommsDeviceObject);
    if (NT_SUCCESS(Status))
    {
        /* Setup a symbolic link for the device */
        RtlInitUnicodeString(&SymLinkName, L"\\DosDevices\\FltMgrMsg");
        Status = IoCreateSymbolicLink(&SymLinkName, &CommsDeviceName);
    }
 
Quit:
    if (!NT_SUCCESS(Status))
    {
        /* Something went wrong, undo */
        if (CommsDeviceObject)
        {
            IoDeleteDevice(CommsDeviceObject);
            CommsDeviceObject = NULL;
        }
        if (ClientPortObjectType)
        {
            ObMakeTemporaryObject(ClientPortObjectType);
            ObDereferenceObject(ClientPortObjectType);
            ClientPortObjectType = NULL;
        }
 
        if (ServerPortObjectType)
        {
            ObMakeTemporaryObject(ServerPortObjectType);
            ObDereferenceObject(ServerPortObjectType);
            ServerPortObjectType = NULL;
        }
    }
 
    return Status;
}

Referenced by CODE_SEG().

InitializeMessageWaiterQueue()

static NTSTATUS InitializeMessageWaiterQueue ( _Inout_ PFLT_MESSAGE_WAITER_QUEUE  MsgWaiterQueue )

static

Definition at line 783 of file Messaging.c.

{
    NTSTATUS Status;
 
    /* Setup the IRP queue */
    Status = IoCsqInitializeEx(&MsgWaiterQueue->Csq,
                               FltpAddMessageWaiter,
                               FltpRemoveMessageWaiter,
                               FltpGetNextMessageWaiter,
                               FltpAcquireMessageWaiterLock,
                               FltpReleaseMessageWaiterLock,
                               FltpCancelMessageWaiter);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Initialize the waiter queue */
    ExInitializeFastMutex(&MsgWaiterQueue->WaiterQ.mLock);
    InitializeListHead(&MsgWaiterQueue->WaiterQ.mList);
    MsgWaiterQueue->WaiterQ.mCount = 0;
 
    /* We don't have a minimum waiter length */
    MsgWaiterQueue->MinimumWaiterLength = (ULONG)-1;
 
    /* Init the semaphore and event used for counting and signaling available IRPs */
    KeInitializeSemaphore(&MsgWaiterQueue->Semaphore, 0, MAXLONG);
    KeInitializeEvent(&MsgWaiterQueue->Event, NotificationEvent, FALSE);
 
    return STATUS_SUCCESS;
}

Referenced by CreateClientPort().

Variable Documentation

ClientPortObjectType

POBJECT_TYPE ClientPortObjectType

Definition at line 25 of file Messaging.c.

Referenced by CreateClientPort(), and FltpSetupCommunicationObjects().

CommsDeviceName

UNICODE_STRING CommsDeviceName = RTL_CONSTANT_STRING(L"\\FileSystem\\Filters\\FltMgrMsg")

Definition at line 21 of file Messaging.c.

Referenced by FltpSetupCommunicationObjects().

CommsDeviceObject

PDEVICE_OBJECT CommsDeviceObject

Definition at line 22 of file Messaging.c.

Referenced by FltpCreate(), FltpDispatch(), and FltpSetupCommunicationObjects().

ServerPortObjectType

POBJECT_TYPE ServerPortObjectType

Definition at line 24 of file Messaging.c.

Referenced by _IRQL_requires_max_(), CreateClientPort(), and FltpSetupCommunicationObjects().