Messaging.c

Go to the documentation of this file.

/*
* PROJECT:         Filesystem Filter Manager
* LICENSE:         GPL - See COPYING in the top level directory
* FILE:            drivers/filters/fltmgr/Messaging.c
* PURPOSE:         Contains the routines to handle the comms layer
* PROGRAMMERS:     Ged Murphy (gedmurphy@reactos.org)
*/
 
/* INCLUDES ******************************************************************/
 
#include "fltmgr.h"
#include "fltmgrint.h"
#include <fltmgr_shared.h>
 
#define NDEBUG
#include <debug.h>
 
 
/* DATA *********************************************************************/
 
UNICODE_STRING CommsDeviceName = RTL_CONSTANT_STRING(L"\\FileSystem\\Filters\\FltMgrMsg");
PDEVICE_OBJECT CommsDeviceObject;
 
POBJECT_TYPE ServerPortObjectType;
POBJECT_TYPE ClientPortObjectType;
 
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
);
 
 
 
/* EXPORTED FUNCTIONS ******************************************************/
 
_Must_inspect_result_
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS
FLTAPI
FltCreateCommunicationPort(_In_ PFLT_FILTER Filter,
                           _Outptr_ PFLT_PORT *ServerPort,
                           _In_ POBJECT_ATTRIBUTES ObjectAttributes,
                           _In_opt_ PVOID ServerPortCookie,
                           _In_ PFLT_CONNECT_NOTIFY ConnectNotifyCallback,
                           _In_ PFLT_DISCONNECT_NOTIFY DisconnectNotifyCallback,
                           _In_opt_ PFLT_MESSAGE_NOTIFY MessageNotifyCallback,
                           _In_ LONG MaxConnections)
{
    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;
}
 
_IRQL_requires_max_(PASSIVE_LEVEL)
VOID
FLTAPI
FltCloseCommunicationPort(_In_ PFLT_PORT ServerPort)
{
    /* Just close the handle to initiate the cleanup callbacks */
    ZwClose(ServerPort);
}
 
_IRQL_requires_max_(PASSIVE_LEVEL)
VOID
FLTAPI
FltCloseClientPort(_In_ PFLT_FILTER Filter,
                   _Inout_ PFLT_PORT *ClientPort)
{
    PFLT_PORT Port;
 
    /* Protect against the handle being used whilst we're closing it */
    FltAcquirePushLockShared(&Filter->PortLock);
 
    /* Store the port handle while we have the lock held */
    Port = *ClientPort;
 
    if (*ClientPort)
    {
        /* Set the hadle to null */
        *ClientPort = NULL;
    }
 
    /* Unlock the port */
    FltReleasePushLock(&Filter->PortLock);
 
    if (Port)
    {
        /* Close the safe handle */
        ZwClose(Port);
    }
}
 
_Must_inspect_result_
_IRQL_requires_max_(APC_LEVEL)
NTSTATUS
FLTAPI
FltSendMessage(_In_ PFLT_FILTER Filter,
               _In_ PFLT_PORT *ClientPort,
               _In_reads_bytes_(SenderBufferLength) PVOID SenderBuffer,
               _In_ ULONG SenderBufferLength,
               _Out_writes_bytes_opt_(*ReplyLength) PVOID ReplyBuffer,
               _Inout_opt_ PULONG ReplyLength,
               _In_opt_ PLARGE_INTEGER Timeout)
{
    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;
}
 
/* INTERNAL FUNCTIONS ******************************************************/
 
 
NTSTATUS
FltpMsgCreate(_In_ PDEVICE_OBJECT DeviceObject,
              _Inout_ PIRP Irp)
{
    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;
}
 
NTSTATUS
FltpMsgDispatch(_In_ PDEVICE_OBJECT DeviceObject,
                _Inout_ PIRP Irp)
{
    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;
}
 
VOID
NTAPI
FltpServerPortClose(_In_opt_ PEPROCESS Process,
                    _In_ PVOID Object,
                    _In_ ACCESS_MASK GrantedAccess,
                    _In_ ULONG ProcessHandleCount,
                    _In_ ULONG SystemHandleCount)
{
    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);
}
 
VOID
NTAPI
FltpServerPortDelete(PVOID Object)
{
    /* 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);
 
}
 
VOID
NTAPI
FltpClientPortClose(_In_opt_ PEPROCESS Process,
                    _In_ PVOID Object,
                    _In_ ACCESS_MASK GrantedAccess,
                    _In_ ULONG ProcessHandleCount,
                    _In_ ULONG SystemHandleCount)
{
    PFLT_PORT_OBJECT PortObject = (PFLT_PORT_OBJECT)Object;
 
    if (FltpDisconnectPort(PortObject))
    {
        InterlockedDecrement(&PortObject->ServerPort->NumberOfConnections);
    }
}
 
BOOLEAN
FltpDisconnectPort(_In_ PFLT_PORT_OBJECT PortObject)
{
    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;
}
 
VOID
NTAPI
FltpClientPortDelete(PVOID Object)
{
    PFLT_PORT_OBJECT PortObject = (PFLT_PORT_OBJECT)Object;
    ObDereferenceObject(PortObject->ServerPort);
}
 
 
NTSTATUS
FltpSetupCommunicationObjects(_In_ PDRIVER_OBJECT DriverObject)
{
    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;
}
 
/* CSQ IRP CALLBACKS *******************************************************/
 
 
NTSTATUS
NTAPI
FltpAddMessageWaiter(_In_ PIO_CSQ Csq,
                     _In_ PIRP Irp,
                     _In_ PVOID InsertContext)
{
    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;
}
 
VOID
NTAPI
FltpRemoveMessageWaiter(_In_ PIO_CSQ Csq,
                        _In_ PIRP Irp)
{
    /* Remove the IRP from the queue */
    RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
}
 
PIRP
NTAPI
FltpGetNextMessageWaiter(_In_ PIO_CSQ Csq,
                         _In_ PIRP Irp,
                         _In_ PVOID PeekContext)
{
    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;
}
 
_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)
{
    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);
}
 
_Releases_lock_(((PFLT_MESSAGE_WAITER_QUEUE)CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue))->WaiterQ.mLock)
_IRQL_restores_global_(Irql, ((PFLT_MESSAGE_WAITER_QUEUE)CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue))->WaiterQ.mLock)
_IRQL_requires_(DISPATCH_LEVEL)
VOID
NTAPI
FltpReleaseMessageWaiterLock(_In_ PIO_CSQ Csq,
                             _In_ KIRQL Irql)
{
    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);
 
    /* Release the IRP queue lock */
    ExReleaseFastMutex(&MessageWaiterQueue->WaiterQ.mLock);
}
 
VOID
NTAPI
FltpCancelMessageWaiter(_In_ PIO_CSQ Csq,
                        _In_ PIRP Irp)
{
    /* Cancel the IRP */
    Irp->IoStatus.Status = STATUS_CANCELLED;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
 
 
/* PRIVATE FUNCTIONS ******************************************************/
 
static
NTSTATUS
CreateClientPort(_In_ PFILE_OBJECT FileObject,
                   _Inout_ PIRP Irp)
{
    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;
}
 
static
NTSTATUS
CloseClientPort(_In_ PFILE_OBJECT FileObject,
                _Inout_ PIRP Irp)
{
    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;
}
 
static
NTSTATUS
InitializeMessageWaiterQueue(_Inout_ PFLT_MESSAGE_WAITER_QUEUE MsgWaiterQueue)
{
    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;
}
 
static
PPORT_CCB
CreatePortCCB(_In_ PFLT_PORT_OBJECT PortObject)
{
    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;
}