statesup.c File Reference

#include "npfs.h"

Include dependency graph for statesup.c:

Go to the source code of this file.

Macros
#define	NPFS_BUGCHECK_FILE_ID   (NPFS_BUGCHECK_STATESUP)

Functions
VOID NTAPI	NpCancelListeningQueueIrp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	NpSetConnectedPipeState (IN PNP_CCB Ccb, IN PFILE_OBJECT FileObject, IN PLIST_ENTRY List)
NTSTATUS NTAPI	NpSetDisconnectedPipeState (IN PNP_CCB Ccb, IN PLIST_ENTRY List)
NTSTATUS NTAPI	NpSetListeningPipeState (IN PNP_CCB Ccb, IN PIRP Irp, IN PLIST_ENTRY List)
NTSTATUS NTAPI	NpSetClosingPipeState (IN PNP_CCB Ccb, IN PIRP Irp, IN ULONG NamedPipeEnd, IN PLIST_ENTRY List)

Macro Definition Documentation

NPFS_BUGCHECK_FILE_ID

#define NPFS_BUGCHECK_FILE_ID   (NPFS_BUGCHECK_STATESUP)

Definition at line 14 of file statesup.c.

Function Documentation

NpCancelListeningQueueIrp()

VOID NTAPI NpCancelListeningQueueIrp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 20 of file statesup.c.

{
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    FsRtlEnterFileSystem();
    NpAcquireExclusiveVcb();
 
    RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
 
    NpReleaseVcb();
    FsRtlExitFileSystem();
 
    Irp->IoStatus.Status = STATUS_CANCELLED;
    IoCompleteRequest(Irp, IO_NAMED_PIPE_INCREMENT);
}

Referenced by NpSetListeningPipeState().

NpSetClosingPipeState()

NTSTATUS NTAPI NpSetClosingPipeState	(	IN PNP_CCB	Ccb,
		IN PIRP	Irp,
		IN ULONG	NamedPipeEnd,
		IN PLIST_ENTRY	List
	)

Definition at line 245 of file statesup.c.

{
    PNP_NONPAGED_CCB NonPagedCcb;
    PNP_FCB Fcb;
    PLIST_ENTRY NextEntry;
    PNP_DATA_QUEUE ReadQueue, WriteQueue, DataQueue;
    PNP_EVENT_BUFFER EventBuffer;
    PIRP ListIrp;
 
    NonPagedCcb = Ccb->NonPagedCcb;
    Fcb = Ccb->Fcb;
 
    switch (Ccb->NamedPipeState)
    {
        case FILE_PIPE_LISTENING_STATE:
 
            ASSERT(NamedPipeEnd == FILE_PIPE_SERVER_END);
 
            while (!IsListEmpty(&Ccb->IrpList))
            {
                NextEntry = RemoveHeadList(&Ccb->IrpList);
 
                ListIrp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
 
                if (IoSetCancelRoutine(ListIrp, NULL))
                {
                    ListIrp->IoStatus.Status = STATUS_PIPE_BROKEN;
                    InsertTailList(List, NextEntry);
                }
                else
                {
                    InitializeListHead(NextEntry);
                }
            }
 
            // Drop on purpose
 
        case FILE_PIPE_DISCONNECTED_STATE:
 
            ASSERT(NamedPipeEnd == FILE_PIPE_SERVER_END);
 
            NpSetFileObject(Ccb->FileObject[FILE_PIPE_SERVER_END], NULL, NULL, TRUE);
            Ccb->FileObject[FILE_PIPE_SERVER_END] = NULL;
 
            NpSetFileObject(Ccb->FileObject[FILE_PIPE_CLIENT_END], NULL, NULL, FALSE);
            Ccb->FileObject[FILE_PIPE_CLIENT_END] = NULL;
 
            NpDeleteCcb(Ccb, List);
            if (!Fcb->CurrentInstances) NpDeleteFcb(Fcb, List);
            break;
 
        case FILE_PIPE_CLOSING_STATE:
 
            if (NamedPipeEnd == FILE_PIPE_SERVER_END)
            {
                DataQueue = &Ccb->DataQueue[FILE_PIPE_INBOUND];
            }
            else
            {
                DataQueue = &Ccb->DataQueue[FILE_PIPE_OUTBOUND];
            }
 
            NpSetFileObject(Ccb->FileObject[FILE_PIPE_SERVER_END], NULL, NULL, TRUE);
            Ccb->FileObject[FILE_PIPE_SERVER_END] = NULL;
 
            NpSetFileObject(Ccb->FileObject[FILE_PIPE_CLIENT_END], NULL, NULL, FALSE);
            Ccb->FileObject[FILE_PIPE_CLIENT_END] = NULL;
 
            while (DataQueue->QueueState != Empty)
            {
                ListIrp = NpRemoveDataQueueEntry(DataQueue, FALSE, List);
                if (ListIrp)
                {
                    ListIrp->IoStatus.Status = STATUS_PIPE_BROKEN;
                    InsertTailList(List, &ListIrp->Tail.Overlay.ListEntry);
                }
            }
 
            NpUninitializeSecurity(Ccb);
 
            if (Ccb->ClientSession)
            {
                ExFreePool(Ccb->ClientSession);
                Ccb->ClientSession = NULL;
            }
 
            NpDeleteCcb(Ccb, List);
            if (!Fcb->CurrentInstances) NpDeleteFcb(Fcb, List);
            break;
 
        case FILE_PIPE_CONNECTED_STATE:
 
            if (NamedPipeEnd == FILE_PIPE_SERVER_END)
            {
                ReadQueue = &Ccb->DataQueue[FILE_PIPE_INBOUND];
                WriteQueue = &Ccb->DataQueue[FILE_PIPE_OUTBOUND];
 
                NpSetFileObject(Ccb->FileObject[FILE_PIPE_SERVER_END], NULL, NULL, TRUE);
                Ccb->FileObject[FILE_PIPE_SERVER_END] = NULL;
            }
            else
            {
                ReadQueue = &Ccb->DataQueue[FILE_PIPE_OUTBOUND];
                WriteQueue = &Ccb->DataQueue[FILE_PIPE_INBOUND];
 
                NpSetFileObject(Ccb->FileObject[FILE_PIPE_CLIENT_END], NULL, NULL, FALSE);
                Ccb->FileObject[FILE_PIPE_CLIENT_END] = NULL;
            }
 
            EventBuffer = NonPagedCcb->EventBuffer[NamedPipeEnd];
 
            Ccb->NamedPipeState = FILE_PIPE_CLOSING_STATE;
 
            while (ReadQueue->QueueState != Empty)
            {
                ListIrp = NpRemoveDataQueueEntry(ReadQueue, FALSE, List);
                if (ListIrp)
                {
                    ListIrp->IoStatus.Status = STATUS_PIPE_BROKEN;
                    InsertTailList(List, &ListIrp->Tail.Overlay.ListEntry);
                }
            }
 
            while (WriteQueue->QueueState == ReadEntries)
            {
                ListIrp = NpRemoveDataQueueEntry(WriteQueue, FALSE, List);
                if (ListIrp)
                {
                    ListIrp->IoStatus.Status = STATUS_PIPE_BROKEN;
                    InsertTailList(List, &ListIrp->Tail.Overlay.ListEntry);
                }
            }
 
            if (EventBuffer) KeSetEvent(EventBuffer->Event, IO_NO_INCREMENT, FALSE);
            break;
 
        default:
            NpBugCheck(Ccb->NamedPipeState, 0, 0);
            break;
    }
    return STATUS_SUCCESS;
}

Referenced by NpCommonCleanup().

NpSetConnectedPipeState()

NTSTATUS NTAPI NpSetConnectedPipeState	(	IN PNP_CCB	Ccb,
		IN PFILE_OBJECT	FileObject,
		IN PLIST_ENTRY	List
	)

Definition at line 39 of file statesup.c.

{
    PLIST_ENTRY NextEntry;
    PIRP Irp;
 
    ASSERT(Ccb->NamedPipeState == FILE_PIPE_LISTENING_STATE);
 
    Ccb->ReadMode[FILE_PIPE_CLIENT_END] = FILE_PIPE_BYTE_STREAM_MODE;
    Ccb->CompletionMode[FILE_PIPE_CLIENT_END] = FILE_PIPE_QUEUE_OPERATION;
    Ccb->NamedPipeState = FILE_PIPE_CONNECTED_STATE;
    Ccb->FileObject[FILE_PIPE_CLIENT_END] = FileObject;
 
    NpSetFileObject(FileObject, Ccb, Ccb->NonPagedCcb, FALSE);
 
    while (!IsListEmpty(&Ccb->IrpList))
    {
        NextEntry = RemoveHeadList(&Ccb->IrpList);
 
        Irp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
 
        if (IoSetCancelRoutine(Irp, NULL))
        {
            Irp->IoStatus.Status = STATUS_SUCCESS;
            InsertTailList(List, NextEntry);
        }
        else
        {
            InitializeListHead(NextEntry);
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by NpCreateClientEnd().

NpSetDisconnectedPipeState()

NTSTATUS NTAPI NpSetDisconnectedPipeState	(	IN PNP_CCB	Ccb,
		IN PLIST_ENTRY	List
	)

Definition at line 77 of file statesup.c.

{
    PIRP Irp;
    PNP_NONPAGED_CCB NonPagedCcb;
    NTSTATUS Status;
    PLIST_ENTRY NextEntry;
    PNP_EVENT_BUFFER EventBuffer;
 
    NonPagedCcb = Ccb->NonPagedCcb;
 
    switch (Ccb->NamedPipeState)
    {
        case FILE_PIPE_DISCONNECTED_STATE:
            Status = STATUS_PIPE_DISCONNECTED;
            break;
 
        case FILE_PIPE_LISTENING_STATE:
            while (!IsListEmpty(&Ccb->IrpList))
            {
                NextEntry = RemoveHeadList(&Ccb->IrpList);
 
                Irp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
 
                if (IoSetCancelRoutine(Irp, NULL))
                {
                    Irp->IoStatus.Status = STATUS_PIPE_DISCONNECTED;
                    InsertTailList(List, NextEntry);
                }
                else
                {
                    InitializeListHead(NextEntry);
                }
            }
 
            Status = STATUS_SUCCESS;
            break;
 
        case FILE_PIPE_CONNECTED_STATE:
 
            EventBuffer = NonPagedCcb->EventBuffer[FILE_PIPE_CLIENT_END];
 
            while (Ccb->DataQueue[FILE_PIPE_INBOUND].QueueState != Empty)
            {
                Irp = NpRemoveDataQueueEntry(&Ccb->DataQueue[FILE_PIPE_INBOUND], FALSE, List);
                if (Irp)
                {
                    Irp->IoStatus.Status = STATUS_PIPE_DISCONNECTED;
                    InsertTailList(List, &Irp->Tail.Overlay.ListEntry);
                }
            }
 
            while (Ccb->DataQueue[FILE_PIPE_OUTBOUND].QueueState != Empty)
            {
                Irp = NpRemoveDataQueueEntry(&Ccb->DataQueue[FILE_PIPE_OUTBOUND], FALSE, List);
                if (Irp)
                {
                    Irp->IoStatus.Status = STATUS_PIPE_DISCONNECTED;
                    InsertTailList(List, &Irp->Tail.Overlay.ListEntry);
                }
            }
 
            if (EventBuffer) KeSetEvent(EventBuffer->Event, IO_NO_INCREMENT, FALSE);
 
            // drop down on purpose... queue will be empty so flush code is nop
            ASSERT(Ccb->DataQueue[FILE_PIPE_OUTBOUND].QueueState == Empty);
 
        case FILE_PIPE_CLOSING_STATE:
 
            EventBuffer = NonPagedCcb->EventBuffer[FILE_PIPE_CLIENT_END];
 
            while (Ccb->DataQueue[FILE_PIPE_INBOUND].QueueState != Empty)
            {
                Irp = NpRemoveDataQueueEntry(&Ccb->DataQueue[FILE_PIPE_INBOUND], FALSE, List);
                if (Irp)
                {
                    Irp->IoStatus.Status = STATUS_PIPE_DISCONNECTED;
                    InsertTailList(List, &Irp->Tail.Overlay.ListEntry);
                }
            }
 
            ASSERT(Ccb->DataQueue[FILE_PIPE_OUTBOUND].QueueState == Empty);
 
            NpDeleteEventTableEntry(&NpVcb->EventTable, EventBuffer);
            NonPagedCcb->EventBuffer[FILE_PIPE_CLIENT_END] = NULL;
 
            NpSetFileObject(Ccb->FileObject[FILE_PIPE_CLIENT_END], NULL, NULL, FALSE);
            Ccb->FileObject[FILE_PIPE_CLIENT_END] = NULL;
 
            NpUninitializeSecurity(Ccb);
 
            if (Ccb->ClientSession)
            {
                ExFreePool(Ccb->ClientSession);
                Ccb->ClientSession = NULL;
            }
 
            Status = STATUS_SUCCESS;
            break;
 
        default:
            NpBugCheck(Ccb->NamedPipeState, 0, 0);
            break;
    }
 
    Ccb->NamedPipeState = FILE_PIPE_DISCONNECTED_STATE;
    return Status;
}

Referenced by NpDisconnect().

NpSetListeningPipeState()

NTSTATUS NTAPI NpSetListeningPipeState	(	IN PNP_CCB	Ccb,
		IN PIRP	Irp,
		IN PLIST_ENTRY	List
	)

Definition at line 188 of file statesup.c.

{
    NTSTATUS Status;
 
    switch (Ccb->NamedPipeState)
    {
        case FILE_PIPE_DISCONNECTED_STATE:
 
            Status = NpCancelWaiter(&NpVcb->WaitQueue,
                                    &Ccb->Fcb->FullName,
                                    STATUS_SUCCESS,
                                    List);
            if (!NT_SUCCESS(Status)) return Status;
 
        //
        // Drop down on purpose
        //
 
        case FILE_PIPE_LISTENING_STATE:
 
            if (Ccb->CompletionMode[FILE_PIPE_SERVER_END] == FILE_PIPE_COMPLETE_OPERATION)
            {
                Ccb->NamedPipeState = FILE_PIPE_LISTENING_STATE;
                return STATUS_PIPE_LISTENING;
            }
 
            IoSetCancelRoutine(Irp, NpCancelListeningQueueIrp);
            if (Irp->Cancel && IoSetCancelRoutine(Irp, NULL))
            {
                return STATUS_CANCELLED;
            }
 
            Ccb->NamedPipeState = FILE_PIPE_LISTENING_STATE;
            IoMarkIrpPending(Irp);
            InsertTailList(&Ccb->IrpList, &Irp->Tail.Overlay.ListEntry);
            return STATUS_PENDING;
 
        case FILE_PIPE_CONNECTED_STATE:
            Status = STATUS_PIPE_CONNECTED;
            break;
 
        case FILE_PIPE_CLOSING_STATE:
            Status = STATUS_PIPE_CLOSING;
            break;
 
        default:
            NpBugCheck(Ccb->NamedPipeState, 0, 0);
            break;
    }
 
    return Status;
}

Referenced by NpListen().