/*
* COPYRIGHT:  See COPYING in the top level directory
* PROJECT:    ReactOS kernel
* FILE:       drivers/fs/np/create.c
* PURPOSE:    Named pipe filesystem
* PROGRAMMER: David Welch <welch@cwcom.net>
*/

/* INCLUDES ******************************************************************/

#include "npfs.h"

#define NDEBUG
#include <debug.h>

/* FUNCTIONS *****************************************************************/

static PNPFS_FCB
NpfsFindPipe(PNPFS_DEVICE_EXTENSION DeviceExt,
             PUNICODE_STRING PipeName)
{
    PLIST_ENTRY CurrentEntry;
    PNPFS_FCB Fcb;

    CurrentEntry = DeviceExt->PipeListHead.Flink;
    while (CurrentEntry != &DeviceExt->PipeListHead)
    {
        Fcb = CONTAINING_RECORD(CurrentEntry, NPFS_FCB, PipeListEntry);
        if (RtlCompareUnicodeString(PipeName,
            &Fcb->PipeName,
            TRUE) == 0)
        {
            DPRINT("<%wZ> = <%wZ>\n", PipeName, &Fcb->PipeName);
            return Fcb;
        }

        CurrentEntry = CurrentEntry->Flink;
    }

    return NULL;
}


static PNPFS_CCB
NpfsFindListeningServerInstance(PNPFS_FCB Fcb)
{
    PLIST_ENTRY CurrentEntry;
    PNPFS_WAITER_ENTRY Waiter;
    KIRQL oldIrql;
    PIRP Irp;

    CurrentEntry = Fcb->WaiterListHead.Flink;
    while (CurrentEntry != &Fcb->WaiterListHead)
    {
        Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry);
        Irp = CONTAINING_RECORD(Waiter, IRP, Tail.Overlay.DriverContext);
        if (Waiter->Ccb->PipeState == FILE_PIPE_LISTENING_STATE)
        {
            DPRINT("Server found! CCB %p\n", Waiter->Ccb);

            IoAcquireCancelSpinLock(&oldIrql);
            if (!Irp->Cancel)
            {
                (void)IoSetCancelRoutine(Irp, NULL);
                IoReleaseCancelSpinLock(oldIrql);
                return Waiter->Ccb;
            }
            IoReleaseCancelSpinLock(oldIrql);
        }

        CurrentEntry = CurrentEntry->Flink;
    }

    return NULL;
}


static VOID
NpfsSignalAndRemoveListeningServerInstance(PNPFS_FCB Fcb,
                                           PNPFS_CCB Ccb)
{
    PLIST_ENTRY CurrentEntry;
    PNPFS_WAITER_ENTRY Waiter;
    PIRP Irp;

    CurrentEntry = Fcb->WaiterListHead.Flink;
    while (CurrentEntry != &Fcb->WaiterListHead)
    {
        Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry);
        if (Waiter->Ccb == Ccb)
        {
            DPRINT("Server found! CCB %p\n", Waiter->Ccb);

            RemoveEntryList(&Waiter->Entry);
            Irp = CONTAINING_RECORD(Waiter, IRP, Tail.Overlay.DriverContext);
            Irp->IoStatus.Status = STATUS_SUCCESS;
            Irp->IoStatus.Information = 0;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            break;
        }
        CurrentEntry = CurrentEntry->Flink;
    }
}


NTSTATUS NTAPI
NpfsCreate(PDEVICE_OBJECT DeviceObject,
           PIRP Irp)
{
    PEXTENDED_IO_STACK_LOCATION IoStack;
    PFILE_OBJECT FileObject;
    PNPFS_FCB Fcb;
    PNPFS_CCB ClientCcb;
    PNPFS_CCB ServerCcb = NULL;
    PNPFS_DEVICE_EXTENSION DeviceExt;
    BOOLEAN SpecialAccess;
    ACCESS_MASK DesiredAccess;

    DPRINT("NpfsCreate(DeviceObject %p Irp %p)\n", DeviceObject, Irp);

    DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    IoStack = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation(Irp);
    FileObject = IoStack->FileObject;
    DesiredAccess = IoStack->Parameters.CreatePipe.SecurityContext->DesiredAccess;
    DPRINT("FileObject %p\n", FileObject);
    DPRINT("FileName %wZ\n", &FileObject->FileName);

    Irp->IoStatus.Information = 0;

    SpecialAccess = ((DesiredAccess & SPECIFIC_RIGHTS_ALL) == FILE_READ_ATTRIBUTES);
    if (SpecialAccess)
    {
        DPRINT("NpfsCreate() open client end for special use!\n");
    }

    /*
    * Step 1. Find the pipe we're trying to open.
    */
    KeLockMutex(&DeviceExt->PipeListLock);
    Fcb = NpfsFindPipe(DeviceExt,
        &FileObject->FileName);
    if (Fcb == NULL)
    {
        /* Not found, bail out with error. */
        DPRINT("No pipe found!\n");
        KeUnlockMutex(&DeviceExt->PipeListLock);
        Irp->IoStatus.Status = STATUS_OBJECT_NAME_NOT_FOUND;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_OBJECT_NAME_NOT_FOUND;
    }

    KeUnlockMutex(&DeviceExt->PipeListLock);

    /*
    * Acquire the lock for CCB lists. From now on no modifications to the
    * CCB lists are allowed, because it can cause various misconsistencies.
    */
    KeLockMutex(&Fcb->CcbListLock);

    /*
    * Step 2. Create the client CCB.
    */
    ClientCcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_CCB));
    if (ClientCcb == NULL)
    {
        DPRINT("No memory!\n");
        KeUnlockMutex(&Fcb->CcbListLock);
        Irp->IoStatus.Status = STATUS_NO_MEMORY;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_NO_MEMORY;
    }

    ClientCcb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread;
    ClientCcb->Fcb = Fcb;
    ClientCcb->PipeEnd = FILE_PIPE_CLIENT_END;
    ClientCcb->OtherSide = NULL;
    ClientCcb->PipeState = SpecialAccess ? 0 : FILE_PIPE_DISCONNECTED_STATE;
    InitializeListHead(&ClientCcb->ReadRequestListHead);

    DPRINT("CCB: %p\n", ClientCcb);

    /* Initialize data list. */
    if (Fcb->OutboundQuota)
    {
        ClientCcb->Data = ExAllocatePool(PagedPool, Fcb->OutboundQuota);
        if (ClientCcb->Data == NULL)
        {
            DPRINT("No memory!\n");
            ExFreePool(ClientCcb);
            KeUnlockMutex(&Fcb->CcbListLock);
            Irp->IoStatus.Status = STATUS_NO_MEMORY;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_NO_MEMORY;
        }
    }
    else
    {
        ClientCcb->Data = NULL;
    }

    ClientCcb->ReadPtr = ClientCcb->Data;
    ClientCcb->WritePtr = ClientCcb->Data;
    ClientCcb->ReadDataAvailable = 0;
    ClientCcb->WriteQuotaAvailable = Fcb->OutboundQuota;
    ClientCcb->MaxDataLength = Fcb->OutboundQuota;
    ExInitializeFastMutex(&ClientCcb->DataListLock);
    KeInitializeEvent(&ClientCcb->ConnectEvent, SynchronizationEvent, FALSE);
    KeInitializeEvent(&ClientCcb->ReadEvent, SynchronizationEvent, FALSE);
    KeInitializeEvent(&ClientCcb->WriteEvent, SynchronizationEvent, FALSE);


    /*
    * Step 3. Search for listening server CCB.
    */

    if (!SpecialAccess)
    {
        /*
        * WARNING: Point of no return! Once we get the server CCB it's
        * possible that we completed a wait request and so we have to
        * complete even this request.
        */

        ServerCcb = NpfsFindListeningServerInstance(Fcb);
        if (ServerCcb == NULL)
        {
            PLIST_ENTRY CurrentEntry;
            PNPFS_CCB Ccb;

            /*
            * If no waiting server CCB was found then try to pick
            * one of the listing server CCB on the pipe.
            */

            CurrentEntry = Fcb->ServerCcbListHead.Flink;
            while (CurrentEntry != &Fcb->ServerCcbListHead)
            {
                Ccb = CONTAINING_RECORD(CurrentEntry, NPFS_CCB, CcbListEntry);
                if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE)
                {
                    ServerCcb = Ccb;
                    break;
                }
                CurrentEntry = CurrentEntry->Flink;
            }

            /*
            * No one is listening to me?! I'm so lonely... :(
            */

            if (ServerCcb == NULL)
            {
                /* Not found, bail out with error for FILE_OPEN requests. */
                DPRINT("No listening server CCB found!\n");
                if (ClientCcb->Data)
                {
                    ExFreePool(ClientCcb->Data);
                    ClientCcb->Data = NULL;
                }
                KeUnlockMutex(&Fcb->CcbListLock);
                Irp->IoStatus.Status = STATUS_OBJECT_PATH_NOT_FOUND;
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
                return STATUS_OBJECT_PATH_NOT_FOUND;
            }
        }
        else
        {
            /* Signal the server thread and remove it from the waiter list */
            /* FIXME: Merge this with the NpfsFindListeningServerInstance routine. */
            NpfsSignalAndRemoveListeningServerInstance(Fcb, ServerCcb);
        }
    }
    else if (IsListEmpty(&Fcb->ServerCcbListHead))
    {
        DPRINT("No server fcb found!\n");
        KeUnlockMutex(&Fcb->CcbListLock);
        Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_UNSUCCESSFUL;
    }

    /*
    * Step 4. Add the client CCB to a list and connect it if possible.
    */

    /* Add the client CCB to the pipe CCB list. */
    InsertTailList(&Fcb->ClientCcbListHead, &ClientCcb->CcbListEntry);

    /* Connect to listening server side */
    if (ServerCcb)
    {
        ClientCcb->OtherSide = ServerCcb;
        ServerCcb->OtherSide = ClientCcb;
        ClientCcb->PipeState = FILE_PIPE_CONNECTED_STATE;
        ServerCcb->PipeState = FILE_PIPE_CONNECTED_STATE;
        KeSetEvent(&ServerCcb->ConnectEvent, IO_NO_INCREMENT, FALSE);
    }

    KeUnlockMutex(&Fcb->CcbListLock);

    FileObject->FsContext = Fcb;
    FileObject->FsContext2 = ClientCcb;
    FileObject->Flags |= FO_NAMED_PIPE;

    Irp->IoStatus.Status = STATUS_SUCCESS;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);

    DPRINT("Success!\n");

    return STATUS_SUCCESS;
}


NTSTATUS NTAPI
NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
                    PIRP Irp)
{
    PEXTENDED_IO_STACK_LOCATION IoStack;
    PFILE_OBJECT FileObject;
    PNPFS_DEVICE_EXTENSION DeviceExt;
    PNPFS_FCB Fcb;
    PNPFS_CCB Ccb;
    PNAMED_PIPE_CREATE_PARAMETERS Buffer;
    BOOLEAN NewPipe = FALSE;

    DPRINT("NpfsCreateNamedPipe(DeviceObject %p Irp %p)\n", DeviceObject, Irp);

    DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    IoStack = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation(Irp);
    FileObject = IoStack->FileObject;
    DPRINT("FileObject %p\n", FileObject);
    DPRINT("Pipe name %wZ\n", &FileObject->FileName);

    Buffer = IoStack->Parameters.CreatePipe.Parameters;

    Irp->IoStatus.Information = 0;

    if (!(IoStack->Parameters.CreatePipe.ShareAccess & (FILE_SHARE_READ|FILE_SHARE_WRITE)) ||
        (IoStack->Parameters.CreatePipe.ShareAccess & ~(FILE_SHARE_READ|FILE_SHARE_WRITE)))
    {
        Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_INVALID_PARAMETER;
    }

    Ccb = ExAllocatePool(NonPagedPool, sizeof(NPFS_CCB));
    if (Ccb == NULL)
    {
        Irp->IoStatus.Status = STATUS_NO_MEMORY;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_NO_MEMORY;
    }

    Ccb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread;
    KeLockMutex(&DeviceExt->PipeListLock);

    /*
    * First search for existing Pipe with the same name.
    */
    Fcb = NpfsFindPipe(DeviceExt,
        &FileObject->FileName);
    if (Fcb != NULL)
    {
        /*
        * Found Pipe with the same name. Check if we are
        * allowed to use it.
        */
        KeUnlockMutex(&DeviceExt->PipeListLock);

        if (Fcb->CurrentInstances >= Fcb->MaximumInstances)
        {
            DPRINT("Out of instances.\n");
            ExFreePool(Ccb);
            Irp->IoStatus.Status = STATUS_INSTANCE_NOT_AVAILABLE;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_INSTANCE_NOT_AVAILABLE;
        }

        if (Fcb->MaximumInstances != Buffer->MaximumInstances ||
            Fcb->TimeOut.QuadPart != Buffer->DefaultTimeout.QuadPart ||
            Fcb->PipeType != Buffer->NamedPipeType)
        {
            DPRINT("Asked for invalid pipe mode.\n");
            ExFreePool(Ccb);
            Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_ACCESS_DENIED;
        }
    }
    else
    {
        NewPipe = TRUE;
        Fcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_FCB));
        if (Fcb == NULL)
        {
            KeUnlockMutex(&DeviceExt->PipeListLock);
            ExFreePool(Ccb);
            Irp->IoStatus.Status = STATUS_NO_MEMORY;
            Irp->IoStatus.Information = 0;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_NO_MEMORY;
        }

        Fcb->PipeName.Length = FileObject->FileName.Length;
        Fcb->PipeName.MaximumLength = Fcb->PipeName.Length + sizeof(UNICODE_NULL);
        Fcb->PipeName.Buffer = ExAllocatePool(NonPagedPool, Fcb->PipeName.MaximumLength);
        if (Fcb->PipeName.Buffer == NULL)
        {
            KeUnlockMutex(&DeviceExt->PipeListLock);
            ExFreePool(Fcb);
            ExFreePool(Ccb);
            Irp->IoStatus.Status = STATUS_NO_MEMORY;
            Irp->IoStatus.Information = 0;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_NO_MEMORY;
        }

        RtlCopyUnicodeString(&Fcb->PipeName, &FileObject->FileName);

        InitializeListHead(&Fcb->ServerCcbListHead);
        InitializeListHead(&Fcb->ClientCcbListHead);
        InitializeListHead(&Fcb->WaiterListHead);
        KeInitializeMutex(&Fcb->CcbListLock, 0);

        Fcb->PipeType = Buffer->NamedPipeType;
        Fcb->ServerReadMode = Buffer->ReadMode;
        /* MSDN documentation reads that clients always start off in byte mode */
        Fcb->ClientReadMode = FILE_PIPE_BYTE_STREAM_MODE;

        Fcb->CompletionMode = Buffer->CompletionMode;
        switch (IoStack->Parameters.CreatePipe.ShareAccess & (FILE_SHARE_READ|FILE_SHARE_WRITE))
        {
        case FILE_SHARE_READ:
            Fcb->PipeConfiguration = FILE_PIPE_OUTBOUND;
            break;
        case FILE_SHARE_WRITE:
            Fcb->PipeConfiguration = FILE_PIPE_INBOUND;
            break;
        case FILE_SHARE_READ|FILE_SHARE_WRITE:
            Fcb->PipeConfiguration = FILE_PIPE_FULL_DUPLEX;
            break;
        }
        Fcb->MaximumInstances = Buffer->MaximumInstances;
        Fcb->CurrentInstances = 0;
        Fcb->TimeOut = Buffer->DefaultTimeout;
        if (!(Fcb->PipeConfiguration & FILE_PIPE_OUTBOUND) ||
            Fcb->PipeConfiguration & FILE_PIPE_FULL_DUPLEX)
        {
            if (Buffer->InboundQuota == 0)
            {
                Fcb->InboundQuota = DeviceExt->DefaultQuota;
            }
            else
            {
                Fcb->InboundQuota = PAGE_ROUND_UP(Buffer->InboundQuota);
                if (Fcb->InboundQuota < DeviceExt->MinQuota)
                {
                    Fcb->InboundQuota = DeviceExt->MinQuota;
                }
                else if (Fcb->InboundQuota > DeviceExt->MaxQuota)
                {
                    Fcb->InboundQuota = DeviceExt->MaxQuota;
                }
            }
        }
        else
        {
            Fcb->InboundQuota = 0;
        }

        if (Fcb->PipeConfiguration & (FILE_PIPE_FULL_DUPLEX|FILE_PIPE_OUTBOUND))
        {
            if (Buffer->OutboundQuota == 0)
            {
                Fcb->OutboundQuota = DeviceExt->DefaultQuota;
            }
            else
            {
                Fcb->OutboundQuota = PAGE_ROUND_UP(Buffer->OutboundQuota);
                if (Fcb->OutboundQuota < DeviceExt->MinQuota)
                {
                    Fcb->OutboundQuota = DeviceExt->MinQuota;
                }
                else if (Fcb->OutboundQuota > DeviceExt->MaxQuota)
                {
                    Fcb->OutboundQuota = DeviceExt->MaxQuota;
                }
            }
        }
        else
        {
            Fcb->OutboundQuota = 0;
        }

        InsertTailList(&DeviceExt->PipeListHead, &Fcb->PipeListEntry);
        KeUnlockMutex(&DeviceExt->PipeListLock);
    }

    if (Fcb->InboundQuota)
    {
        Ccb->Data = ExAllocatePool(PagedPool, Fcb->InboundQuota);
        if (Ccb->Data == NULL)
        {
            ExFreePool(Ccb);

            if (NewPipe)
            {
                KeLockMutex(&DeviceExt->PipeListLock);
                RemoveEntryList(&Fcb->PipeListEntry);
                KeUnlockMutex(&DeviceExt->PipeListLock);
                RtlFreeUnicodeString(&Fcb->PipeName);
                ExFreePool(Fcb);
            }

            Irp->IoStatus.Status = STATUS_NO_MEMORY;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_NO_MEMORY;
        }
    }
    else
    {
        Ccb->Data = NULL;
    }

    Ccb->ReadPtr = Ccb->Data;
    Ccb->WritePtr = Ccb->Data;
    Ccb->ReadDataAvailable = 0;
    Ccb->WriteQuotaAvailable = Fcb->InboundQuota;
    Ccb->MaxDataLength = Fcb->InboundQuota;
    InitializeListHead(&Ccb->ReadRequestListHead);
    ExInitializeFastMutex(&Ccb->DataListLock);

    Fcb->CurrentInstances++;

    Ccb->Fcb = Fcb;
    Ccb->PipeEnd = FILE_PIPE_SERVER_END;
    Ccb->PipeState = FILE_PIPE_LISTENING_STATE;
    Ccb->OtherSide = NULL;

    DPRINT("CCB: %p\n", Ccb);

    KeInitializeEvent(&Ccb->ConnectEvent, SynchronizationEvent, FALSE);
    KeInitializeEvent(&Ccb->ReadEvent, SynchronizationEvent, FALSE);
    KeInitializeEvent(&Ccb->WriteEvent, SynchronizationEvent, FALSE);

    KeLockMutex(&Fcb->CcbListLock);
    InsertTailList(&Fcb->ServerCcbListHead, &Ccb->CcbListEntry);
    KeUnlockMutex(&Fcb->CcbListLock);

    FileObject->FsContext = Fcb;
    FileObject->FsContext2 = Ccb;
    FileObject->Flags |= FO_NAMED_PIPE;

    Irp->IoStatus.Status = STATUS_SUCCESS;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);

    DPRINT("Success!\n");

    return STATUS_SUCCESS;
}


NTSTATUS NTAPI
NpfsCleanup(PDEVICE_OBJECT DeviceObject,
            PIRP Irp)
{
    PNPFS_DEVICE_EXTENSION DeviceExt;
    PIO_STACK_LOCATION IoStack;
    PFILE_OBJECT FileObject;
    PNPFS_CCB Ccb, OtherSide;
    PNPFS_FCB Fcb;
    BOOLEAN Server;

    DPRINT("NpfsCleanup(DeviceObject %p Irp %p)\n", DeviceObject, Irp);

    IoStack = IoGetCurrentIrpStackLocation(Irp);
    DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    FileObject = IoStack->FileObject;
    Ccb = FileObject->FsContext2;

    if (Ccb == NULL)
    {
        DPRINT("Success!\n");
        Irp->IoStatus.Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_SUCCESS;
    }

    DPRINT("CCB %p\n", Ccb);
    Fcb = Ccb->Fcb;

    DPRINT("Cleaning pipe %wZ\n", &Fcb->PipeName);

    KeLockMutex(&Fcb->CcbListLock);

    Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END);

    if (Server)
    {
        /* FIXME: Clean up existing connections here ?? */
        DPRINT("Server\n");
    }
    else
    {
        DPRINT("Client\n");
    }
    if ((Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) && (Ccb->OtherSide))
    {
        OtherSide = Ccb->OtherSide;
        /* Lock the server first */
        if (Server)
        {
            ExAcquireFastMutex(&Ccb->DataListLock);
            ExAcquireFastMutex(&OtherSide->DataListLock);
        }
        else
        {
            ExAcquireFastMutex(&OtherSide->DataListLock);
            ExAcquireFastMutex(&Ccb->DataListLock);
        }
        //OtherSide->PipeState = FILE_PIPE_DISCONNECTED_STATE;
        OtherSide->OtherSide = NULL;
        /*
        * Signaling the write event. If is possible that an other
        * thread waits for an empty buffer.
        */
        KeSetEvent(&OtherSide->ReadEvent, IO_NO_INCREMENT, FALSE);
        KeSetEvent(&OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE);
        if (Server)
        {
            ExReleaseFastMutex(&OtherSide->DataListLock);
            ExReleaseFastMutex(&Ccb->DataListLock);
        }
        else
        {
            ExReleaseFastMutex(&Ccb->DataListLock);
            ExReleaseFastMutex(&OtherSide->DataListLock);
        }
    }
    else if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE)
    {
        PLIST_ENTRY Entry;
        PNPFS_WAITER_ENTRY WaitEntry = NULL;
        BOOLEAN Complete = FALSE;
        KIRQL oldIrql;
        PIRP tmpIrp;

        Entry = Ccb->Fcb->WaiterListHead.Flink;
        while (Entry != &Ccb->Fcb->WaiterListHead)
        {
            WaitEntry = CONTAINING_RECORD(Entry, NPFS_WAITER_ENTRY, Entry);
            if (WaitEntry->Ccb == Ccb)
            {
                RemoveEntryList(Entry);
                tmpIrp = CONTAINING_RECORD(WaitEntry, IRP, Tail.Overlay.DriverContext);
                IoAcquireCancelSpinLock(&oldIrql);
                if (!tmpIrp->Cancel)
                {
                    (void)IoSetCancelRoutine(tmpIrp, NULL);
                    Complete = TRUE;
                }
                IoReleaseCancelSpinLock(oldIrql);
                if (Complete)
                {
                    tmpIrp->IoStatus.Status = STATUS_PIPE_BROKEN;
                    tmpIrp->IoStatus.Information = 0;
                    IoCompleteRequest(tmpIrp, IO_NO_INCREMENT);
                }
                break;
            }
            Entry = Entry->Flink;
        }

    }
    Ccb->PipeState = FILE_PIPE_CLOSING_STATE;

    KeUnlockMutex(&Fcb->CcbListLock);

    ExAcquireFastMutex(&Ccb->DataListLock);
    if (Ccb->Data)
    {
        ExFreePool(Ccb->Data);
        Ccb->Data = NULL;
        Ccb->ReadPtr = NULL;
        Ccb->WritePtr = NULL;
    }
    ExReleaseFastMutex(&Ccb->DataListLock);

    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);

    DPRINT("Success!\n");

    return STATUS_SUCCESS;
}

NTSTATUS NTAPI
NpfsClose(PDEVICE_OBJECT DeviceObject,
          PIRP Irp)
{
    PNPFS_DEVICE_EXTENSION DeviceExt;
    PIO_STACK_LOCATION IoStack;
    PFILE_OBJECT FileObject;
    PNPFS_FCB Fcb;
    PNPFS_CCB Ccb;
    BOOLEAN Server;

    DPRINT("NpfsClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp);

    IoStack = IoGetCurrentIrpStackLocation(Irp);
    DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    FileObject = IoStack->FileObject;
    Ccb = FileObject->FsContext2;

    if (Ccb == NULL)
    {
        DPRINT("Success!\n");
        Irp->IoStatus.Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_SUCCESS;
    }

    DPRINT("CCB %p\n", Ccb);
    Fcb = Ccb->Fcb;

    DPRINT("Closing pipe %wZ\n", &Fcb->PipeName);

    KeLockMutex(&Fcb->CcbListLock);

    Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END);

    if (Server)
    {
        DPRINT("Server\n");
        Fcb->CurrentInstances--;
    }
    else
    {
        DPRINT("Client\n");
    }

    /* Disconnect the pipes */
    if (Ccb->OtherSide) Ccb->OtherSide->OtherSide = NULL;
    if (Ccb) Ccb->OtherSide = NULL;

    ASSERT(Ccb->PipeState == FILE_PIPE_CLOSING_STATE);

    FileObject->FsContext2 = NULL;

    RemoveEntryList(&Ccb->CcbListEntry);

    ExFreePool(Ccb);

    KeUnlockMutex(&Fcb->CcbListLock);

    if (IsListEmpty(&Fcb->ServerCcbListHead) &&
        IsListEmpty(&Fcb->ClientCcbListHead))
    {
        RtlFreeUnicodeString(&Fcb->PipeName);
        KeLockMutex(&DeviceExt->PipeListLock);
        RemoveEntryList(&Fcb->PipeListEntry);
        KeUnlockMutex(&DeviceExt->PipeListLock);
        ExFreePool(Fcb);
        FileObject->FsContext = NULL;
    }

    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);

    DPRINT("Success!\n");

    return STATUS_SUCCESS;
}

/* EOF */