msfs.h File Reference

#include <ntifs.h>

Include dependency graph for msfs.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_MSFS_DEVICE_EXTENSION
struct	_MSFS_FCB
struct	_MSFS_DPC_CTX
struct	_MSFS_CCB
struct	_MSFS_MESSAGE

Macros
#define	DEFAULTAPI   NTAPI
#define	KeLockMutex(x)
#define	KeUnlockMutex(x)   KeReleaseMutex(x, FALSE);

Typedefs
typedef struct _MSFS_DEVICE_EXTENSION	MSFS_DEVICE_EXTENSION
typedef struct _MSFS_DEVICE_EXTENSION *	PMSFS_DEVICE_EXTENSION
typedef struct _MSFS_FCB	MSFS_FCB
typedef struct _MSFS_FCB *	PMSFS_FCB
typedef struct _MSFS_DPC_CTX	MSFS_DPC_CTX
typedef struct _MSFS_DPC_CTX *	PMSFS_DPC_CTX
typedef struct _MSFS_CCB	MSFS_CCB
typedef struct _MSFS_CCB *	PMSFS_CCB
typedef struct _MSFS_MESSAGE	MSFS_MESSAGE
typedef struct _MSFS_MESSAGE *	PMSFS_MESSAGE

Functions
NTSTATUS DEFAULTAPI	MsfsCreate (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS DEFAULTAPI	MsfsCreateMailslot (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS DEFAULTAPI	MsfsClose (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS DEFAULTAPI	MsfsQueryInformation (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS DEFAULTAPI	MsfsSetInformation (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS DEFAULTAPI	MsfsRead (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS DEFAULTAPI	MsfsWrite (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS DEFAULTAPI	MsfsFileSystemControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
VOID NTAPI	MsfsInsertIrp (PIO_CSQ Csq, PIRP Irp)
VOID NTAPI	MsfsRemoveIrp (PIO_CSQ Csq, PIRP Irp)
PIRP NTAPI	MsfsPeekNextIrp (PIO_CSQ Csq, PIRP Irp, PVOID PeekContext)
VOID NTAPI	MsfsAcquireLock (PIO_CSQ Csq, PKIRQL Irql)
VOID NTAPI	MsfsReleaseLock (PIO_CSQ Csq, KIRQL Irql)
VOID NTAPI	MsfsCompleteCanceledIrp (PIO_CSQ pCsq, PIRP Irp)
VOID NTAPI	MsfsTimeout (PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)

Variables
DRIVER_DISPATCH	MsfsCreate
DRIVER_DISPATCH	MsfsCreateMailslot
DRIVER_DISPATCH	MsfsClose
DRIVER_DISPATCH	MsfsQueryInformation
DRIVER_DISPATCH	MsfsSetInformation
DRIVER_DISPATCH	MsfsRead
DRIVER_DISPATCH	MsfsWrite
DRIVER_DISPATCH	MsfsFileSystemControl
IO_CSQ_INSERT_IRP	MsfsInsertIrp
IO_CSQ_REMOVE_IRP	MsfsRemoveIrp
IO_CSQ_PEEK_NEXT_IRP	MsfsPeekNextIrp
IO_CSQ_ACQUIRE_LOCK	MsfsAcquireLock
IO_CSQ_RELEASE_LOCK	MsfsReleaseLock
IO_CSQ_COMPLETE_CANCELED_IRP	MsfsCompleteCanceledIrp
KDEFERRED_ROUTINE	MsfsTimeout

Macro Definition Documentation

DEFAULTAPI

#define DEFAULTAPI   NTAPI

Definition at line 15 of file msfs.h.

KeLockMutex

#define KeLockMutex

(

x

)

Value:

                                             KeWaitForSingleObject(x, \
                                             Executive, \
                                             KernelMode, \
                                             FALSE, \
                                             NULL);

Definition at line 69 of file msfs.h.

KeUnlockMutex

#define KeUnlockMutex

(

x

)

KeReleaseMutex(x, FALSE);

Definition at line 75 of file msfs.h.

Typedef Documentation

MSFS_CCB

typedef struct _MSFS_CCB MSFS_CCB

MSFS_DEVICE_EXTENSION

typedef struct _MSFS_DEVICE_EXTENSION MSFS_DEVICE_EXTENSION

MSFS_DPC_CTX

typedef struct _MSFS_DPC_CTX MSFS_DPC_CTX

MSFS_FCB

typedef struct _MSFS_FCB MSFS_FCB

MSFS_MESSAGE

typedef struct _MSFS_MESSAGE MSFS_MESSAGE

PMSFS_CCB

typedef struct _MSFS_CCB * PMSFS_CCB

PMSFS_DEVICE_EXTENSION

typedef struct _MSFS_DEVICE_EXTENSION * PMSFS_DEVICE_EXTENSION

PMSFS_DPC_CTX

typedef struct _MSFS_DPC_CTX * PMSFS_DPC_CTX

PMSFS_FCB

typedef struct _MSFS_FCB * PMSFS_FCB

PMSFS_MESSAGE

typedef struct _MSFS_MESSAGE * PMSFS_MESSAGE

Function Documentation

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	PDRIVER_OBJECT	DriverObject,
		PUNICODE_STRING	RegistryPath
	)

Definition at line 16 of file battc.c.

{
    DPRINT("Battery class driver initialized\n");
 
    return STATUS_SUCCESS;
}

MsfsAcquireLock()

VOID NTAPI MsfsAcquireLock	(	PIO_CSQ	Csq,
		PKIRQL	Irql
	)

Definition at line 80 of file msfssup.c.

{
    PMSFS_FCB Fcb;
 
    Fcb = CONTAINING_RECORD(Csq, MSFS_FCB, CancelSafeQueue);
    KeAcquireSpinLock(&Fcb->QueueLock, Irql);
}

MsfsClose()

NTSTATUS DEFAULTAPI MsfsClose	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 253 of file create.c.

{
    PIO_STACK_LOCATION IoStack;
    PFILE_OBJECT FileObject;
    PMSFS_DEVICE_EXTENSION DeviceExtension;
    PMSFS_FCB Fcb;
    PMSFS_CCB Ccb;
    PMSFS_MESSAGE Message;
    KIRQL oldIrql;
 
    DPRINT("MsfsClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    DeviceExtension = DeviceObject->DeviceExtension;
    FileObject = IoStack->FileObject;
 
    KeLockMutex(&DeviceExtension->FcbListLock);
 
    if (DeviceExtension->FcbListHead.Flink == &DeviceExtension->FcbListHead)
    {
        KeUnlockMutex(&DeviceExtension->FcbListLock);
 
        Irp->IoStatus.Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = 0;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_SUCCESS;
    }
 
    Fcb = FileObject->FsContext;
    Ccb = FileObject->FsContext2;
 
    DPRINT("Mailslot name: %wZ\n", &Fcb->Name);
 
    Fcb->ReferenceCount--;
    if (Fcb->ServerCcb == Ccb)
    {
        /* delete all messages from message-list */
        KeAcquireSpinLock(&Fcb->MessageListLock, &oldIrql);
 
        while (Fcb->MessageListHead.Flink != &Fcb->MessageListHead)
        {
            Message = CONTAINING_RECORD(Fcb->MessageListHead.Flink,
                                        MSFS_MESSAGE,
                                        MessageListEntry);
            RemoveEntryList(Fcb->MessageListHead.Flink);
            ExFreePoolWithTag(Message, 'rFsM');
        }
 
        Fcb->MessageCount = 0;
 
        KeReleaseSpinLock(&Fcb->MessageListLock, oldIrql);
        Fcb->ServerCcb = NULL;
    }
 
    KeAcquireSpinLock(&Fcb->CcbListLock, &oldIrql);
    RemoveEntryList(&Ccb->CcbListEntry);
    KeReleaseSpinLock(&Fcb->CcbListLock, oldIrql);
    ExFreePoolWithTag(Ccb, 'cFsM');
    FileObject->FsContext2 = NULL;
 
    if (Fcb->ReferenceCount == 0)
    {
        DPRINT("ReferenceCount == 0: Deleting mailslot data\n");
        RemoveEntryList(&Fcb->FcbListEntry);
        ExFreePoolWithTag(Fcb->Name.Buffer, 'NFsM');
        ExFreePoolWithTag(Fcb, 'fFsM');
    }
 
    KeUnlockMutex(&DeviceExtension->FcbListLock);
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}

MsfsCompleteCanceledIrp()

VOID NTAPI MsfsCompleteCanceledIrp	(	PIO_CSQ	pCsq,
		PIRP	Irp
	)

Definition at line 99 of file msfssup.c.

{
 
    UNREFERENCED_PARAMETER(Csq);
 
    Irp->IoStatus.Status = STATUS_CANCELLED;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}

MsfsCreate()

NTSTATUS DEFAULTAPI MsfsCreate	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 23 of file create.c.

{
    PIO_STACK_LOCATION IoStack;
    PFILE_OBJECT FileObject;
    PMSFS_DEVICE_EXTENSION DeviceExtension;
    PMSFS_FCB Fcb;
    PMSFS_CCB Ccb;
    PMSFS_FCB current = NULL;
    PLIST_ENTRY current_entry;
    KIRQL oldIrql;
 
    DPRINT("MsfsCreate(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    DeviceExtension = DeviceObject->DeviceExtension;
    FileObject = IoStack->FileObject;
 
    DPRINT("Mailslot name: %wZ\n", &FileObject->FileName);
 
    Ccb = ExAllocatePoolWithTag(NonPagedPool, sizeof(MSFS_CCB), 'cFsM');
    if (Ccb == NULL)
    {
        Irp->IoStatus.Status = STATUS_NO_MEMORY;
        Irp->IoStatus.Information = 0;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_NO_MEMORY;
    }
 
    KeLockMutex(&DeviceExtension->FcbListLock);
    current_entry = DeviceExtension->FcbListHead.Flink;
    while (current_entry != &DeviceExtension->FcbListHead)
    {
        current = CONTAINING_RECORD(current_entry,
                                    MSFS_FCB,
                                    FcbListEntry);
 
        if (!RtlCompareUnicodeString(&FileObject->FileName, &current->Name, TRUE))
            break;
 
        current_entry = current_entry->Flink;
    }
 
    if (current_entry == &DeviceExtension->FcbListHead)
    {
        ExFreePoolWithTag(Ccb, 'cFsM');
        KeUnlockMutex(&DeviceExtension->FcbListLock);
 
        Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
        Irp->IoStatus.Information = 0;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_UNSUCCESSFUL;
    }
 
    Fcb = current;
 
    KeAcquireSpinLock(&Fcb->CcbListLock, &oldIrql);
    InsertTailList(&Fcb->CcbListHead, &Ccb->CcbListEntry);
    KeReleaseSpinLock(&Fcb->CcbListLock, oldIrql);
 
    Fcb->ReferenceCount++;
 
    Ccb->Fcb = Fcb;
 
    KeUnlockMutex(&DeviceExtension->FcbListLock);
 
    FileObject->FsContext = Fcb;
    FileObject->FsContext2 = Ccb;
    FileObject->Flags |= FO_MAILSLOT;
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}

MsfsCreateMailslot()

NTSTATUS DEFAULTAPI MsfsCreateMailslot	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 107 of file create.c.

{
    PIO_STACK_LOCATION IoStack;
    PFILE_OBJECT FileObject;
    PMSFS_DEVICE_EXTENSION DeviceExtension;
    PMSFS_FCB Fcb;
    PMSFS_CCB Ccb;
    KIRQL oldIrql;
    PLIST_ENTRY current_entry;
    PMSFS_FCB current = NULL;
    PMAILSLOT_CREATE_PARAMETERS Buffer;
 
    DPRINT("MsfsCreateMailslot(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    DeviceExtension = DeviceObject->DeviceExtension;
    FileObject = IoStack->FileObject;
    Buffer = IoStack->Parameters.CreateMailslot.Parameters;
 
    DPRINT("Mailslot name: %wZ\n", &FileObject->FileName);
 
    Fcb = ExAllocatePoolWithTag(NonPagedPool, sizeof(MSFS_FCB), 'fFsM');
    if (Fcb == NULL)
    {
        Irp->IoStatus.Status = STATUS_NO_MEMORY;
        Irp->IoStatus.Information = 0;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_NO_MEMORY;
    }
 
    Fcb->Name.Length = FileObject->FileName.Length;
    Fcb->Name.MaximumLength = Fcb->Name.Length + sizeof(UNICODE_NULL);
    Fcb->Name.Buffer = ExAllocatePoolWithTag(NonPagedPool,
                                             Fcb->Name.MaximumLength,
                                             'NFsM');
    if (Fcb->Name.Buffer == NULL)
    {
        ExFreePoolWithTag(Fcb, 'fFsM');
 
        Irp->IoStatus.Status = STATUS_NO_MEMORY;
        Irp->IoStatus.Information = 0;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_NO_MEMORY;
    }
 
    RtlCopyUnicodeString(&Fcb->Name, &FileObject->FileName);
 
    Ccb = ExAllocatePoolWithTag(NonPagedPool, sizeof(MSFS_CCB), 'cFsM');
    if (Ccb == NULL)
    {
        ExFreePoolWithTag(Fcb->Name.Buffer, 'NFsM');
        ExFreePoolWithTag(Fcb, 'fFsM');
 
        Irp->IoStatus.Status = STATUS_NO_MEMORY;
        Irp->IoStatus.Information = 0;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_NO_MEMORY;
    }
 
    Fcb->ReferenceCount = 0;
    InitializeListHead(&Fcb->CcbListHead);
    KeInitializeSpinLock(&Fcb->CcbListLock);
 
    Fcb->MaxMessageSize = Buffer->MaximumMessageSize;
    Fcb->MessageCount = 0;
    Fcb->TimeOut = Buffer->ReadTimeout;
 
    InitializeListHead(&Fcb->MessageListHead);
    KeInitializeSpinLock(&Fcb->MessageListLock);
 
    KeInitializeSpinLock(&Fcb->QueueLock);
    InitializeListHead(&Fcb->PendingIrpQueue);
    IoCsqInitialize(&Fcb->CancelSafeQueue,
                    MsfsInsertIrp,
                    MsfsRemoveIrp,
                    MsfsPeekNextIrp,
                    MsfsAcquireLock,
                    MsfsReleaseLock,
                    MsfsCompleteCanceledIrp);
 
    KeLockMutex(&DeviceExtension->FcbListLock);
    current_entry = DeviceExtension->FcbListHead.Flink;
    while (current_entry != &DeviceExtension->FcbListHead)
    {
        current = CONTAINING_RECORD(current_entry,
                                    MSFS_FCB,
                                    FcbListEntry);
 
        if (!RtlCompareUnicodeString(&Fcb->Name, &current->Name, TRUE))
            break;
 
        current_entry = current_entry->Flink;
    }
 
    if (current_entry != &DeviceExtension->FcbListHead)
    {
        ExFreePoolWithTag(Fcb->Name.Buffer, 'NFsM');
        ExFreePoolWithTag(Fcb, 'fFsM');
        ExFreePoolWithTag(Ccb, 'cFsM');
 
        KeUnlockMutex(&DeviceExtension->FcbListLock);
 
        Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
        Irp->IoStatus.Information = 0;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_UNSUCCESSFUL;
    }
    else
    {
        InsertTailList(&DeviceExtension->FcbListHead,
                       &Fcb->FcbListEntry);
    }
 
    KeAcquireSpinLock(&Fcb->CcbListLock, &oldIrql);
    InsertTailList(&Fcb->CcbListHead, &Ccb->CcbListEntry);
    KeReleaseSpinLock(&Fcb->CcbListLock, oldIrql);
 
    Fcb->ReferenceCount++;
    Fcb->ServerCcb = Ccb;
    Ccb->Fcb = Fcb;
 
    KeUnlockMutex(&DeviceExtension->FcbListLock);
 
    FileObject->FsContext = Fcb;
    FileObject->FsContext2 = Ccb;
    FileObject->Flags |= FO_MAILSLOT;
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}

MsfsFileSystemControl()

NTSTATUS DEFAULTAPI MsfsFileSystemControl	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 19 of file fsctrl.c.

{
    PIO_STACK_LOCATION IoStack;
    PFILE_OBJECT FileObject;
    PMSFS_FCB Fcb;
    NTSTATUS Status;
 
    DPRINT1("MsfsFileSystemControl(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    FileObject = IoStack->FileObject;
    Fcb = FileObject->FsContext;
 
    DPRINT1("Mailslot name: %wZ\n", &Fcb->Name);
 
    switch (IoStack->Parameters.FileSystemControl.FsControlCode)
    {
    default:
        Status = STATUS_NOT_IMPLEMENTED;
    }
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

MsfsInsertIrp()

VOID NTAPI MsfsInsertIrp	(	PIO_CSQ	Csq,
		PIRP	Irp
	)

Definition at line 18 of file msfssup.c.

{
    PMSFS_FCB Fcb;
 
    Fcb = CONTAINING_RECORD(Csq, MSFS_FCB, CancelSafeQueue);
    InsertTailList(&Fcb->PendingIrpQueue, &Irp->Tail.Overlay.ListEntry);
}

MsfsPeekNextIrp()

PIRP NTAPI MsfsPeekNextIrp	(	PIO_CSQ	Csq,
		PIRP	Irp,
		PVOID	PeekContext
	)

Definition at line 35 of file msfssup.c.

{
    PMSFS_FCB Fcb;
    PIRP NextIrp = NULL;
    PLIST_ENTRY NextEntry, ListHead;
    PIO_STACK_LOCATION Stack;
 
    Fcb = CONTAINING_RECORD(Csq, MSFS_FCB, CancelSafeQueue);
 
    ListHead = &Fcb->PendingIrpQueue;
 
    if (Irp == NULL)
    {
        NextEntry = ListHead->Flink;
    }
    else
    {
        NextEntry = Irp->Tail.Overlay.ListEntry.Flink;
    }
 
    for (; NextEntry != ListHead; NextEntry = NextEntry->Flink)
    {
        NextIrp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
 
        Stack = IoGetCurrentIrpStackLocation(NextIrp);
 
        if (PeekContext)
        {
            if (Stack->FileObject == (PFILE_OBJECT)PeekContext)
            {
                break;
            }
        }
        else
        {
            break;
        }
 
        NextIrp = NULL;
    }
 
    return NextIrp;
}

MsfsQueryInformation()

NTSTATUS DEFAULTAPI MsfsQueryInformation	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 72 of file finfo.c.

{
    PIO_STACK_LOCATION IoStack;
    FILE_INFORMATION_CLASS FileInformationClass;
    PFILE_OBJECT FileObject;
    PMSFS_FCB Fcb;
    PMSFS_CCB Ccb;
    PVOID SystemBuffer;
    ULONG BufferLength;
    NTSTATUS Status;
 
    DPRINT("MsfsQueryInformation(DeviceObject %p Irp %p)\n",
           DeviceObject, Irp);
 
    IoStack = IoGetCurrentIrpStackLocation (Irp);
    FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass;
    FileObject = IoStack->FileObject;
    Fcb = (PMSFS_FCB)FileObject->FsContext;
    Ccb = (PMSFS_CCB)FileObject->FsContext2;
 
    DPRINT("Mailslot name: %wZ\n", &Fcb->Name);
 
    /* querying information is not permitted on client side */
    if (Fcb->ServerCcb != Ccb)
    {
        Status = STATUS_ACCESS_DENIED;
 
        Irp->IoStatus.Status = Status;
        Irp->IoStatus.Information = 0;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return Status;
    }
 
    SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
    BufferLength = IoStack->Parameters.QueryFile.Length;
 
    switch (FileInformationClass)
    {
    case FileMailslotQueryInformation:
        Status = MsfsQueryMailslotInformation(Fcb,
                                              SystemBuffer,
                                              &BufferLength);
        break;
 
    default:
        Status = STATUS_NOT_IMPLEMENTED;
    }
 
    Irp->IoStatus.Status = Status;
    if (NT_SUCCESS(Status))
        Irp->IoStatus.Information =
             IoStack->Parameters.QueryFile.Length - BufferLength;
    else
        Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

MsfsRead()

NTSTATUS DEFAULTAPI MsfsRead	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 20 of file rw.c.

{
    PIO_STACK_LOCATION IoStack;
    PFILE_OBJECT FileObject;
    PMSFS_FCB Fcb;
    PMSFS_CCB Ccb;
    PMSFS_MESSAGE Message;
    KIRQL oldIrql;
    ULONG Length;
    ULONG LengthRead = 0;
    PVOID Buffer;
    LARGE_INTEGER Timeout;
    PKTIMER Timer;
    PMSFS_DPC_CTX Context;
    PKDPC Dpc;
    PLIST_ENTRY Entry;
 
    DPRINT("MsfsRead(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
 
    IoStack = IoGetCurrentIrpStackLocation (Irp);
    FileObject = IoStack->FileObject;
    Fcb = (PMSFS_FCB)FileObject->FsContext;
    Ccb = (PMSFS_CCB)FileObject->FsContext2;
 
    DPRINT("MailslotName: %wZ\n", &Fcb->Name);
 
    /* reading is not permitted on client side */
    if (Fcb->ServerCcb != Ccb)
    {
        Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
        Irp->IoStatus.Information = 0;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_ACCESS_DENIED;
    }
 
    Length = IoStack->Parameters.Read.Length;
    if (Irp->MdlAddress)
        Buffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
    else
        Buffer = Irp->UserBuffer;
 
 
    KeAcquireSpinLock(&Fcb->MessageListLock, &oldIrql);
    if (Fcb->MessageCount > 0)
    {
        Entry = RemoveHeadList(&Fcb->MessageListHead);
        Fcb->MessageCount--;
        KeReleaseSpinLock(&Fcb->MessageListLock, oldIrql);
 
        /* copy current message into buffer */
        Message = CONTAINING_RECORD(Entry, MSFS_MESSAGE, MessageListEntry);
        memcpy(Buffer, &Message->Buffer, min(Message->Size,Length));
        LengthRead = Message->Size;
 
        ExFreePoolWithTag(Message, 'rFsM');
 
        Irp->IoStatus.Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = LengthRead;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_SUCCESS;
    }
    else
    {
        KeReleaseSpinLock(&Fcb->MessageListLock, oldIrql);
    }
 
    Timeout = Fcb->TimeOut;
    if (Timeout.HighPart == 0 && Timeout.LowPart == 0)
    {
        Irp->IoStatus.Status = STATUS_IO_TIMEOUT;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_IO_TIMEOUT;
    }
 
    Context = ExAllocatePoolWithTag(NonPagedPool, sizeof(MSFS_DPC_CTX), 'NFsM');
    if (Context == NULL)
    {
        Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    KeInitializeEvent(&Context->Event, SynchronizationEvent, FALSE);
    IoCsqInsertIrp(&Fcb->CancelSafeQueue, Irp, &Context->CsqContext);
    Timer = &Context->Timer;
    Dpc = &Context->Dpc;
    Context->Csq = &Fcb->CancelSafeQueue;
    Irp->Tail.Overlay.DriverContext[0] = Context;
 
    /* No timer for INFINITY_WAIT */
    if (Timeout.QuadPart != -1)
    {
        KeInitializeTimer(Timer);
        KeInitializeDpc(Dpc, MsfsTimeout, (PVOID)Context);
        KeSetTimer(Timer, Timeout, Dpc);
    }
 
    IoMarkIrpPending(Irp);
 
    return STATUS_PENDING;
}

MsfsReleaseLock()

VOID NTAPI MsfsReleaseLock	(	PIO_CSQ	Csq,
		KIRQL	Irql
	)

Definition at line 90 of file msfssup.c.

{
    PMSFS_FCB Fcb;
 
    Fcb = CONTAINING_RECORD(Csq, MSFS_FCB, CancelSafeQueue);
    KeReleaseSpinLock(&Fcb->QueueLock, Irql);
}

MsfsRemoveIrp()

VOID NTAPI MsfsRemoveIrp	(	PIO_CSQ	Csq,
		PIRP	Irp
	)

Definition at line 27 of file msfssup.c.

{
    UNREFERENCED_PARAMETER(Csq);
 
    RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
}

MsfsSetInformation()

NTSTATUS DEFAULTAPI MsfsSetInformation	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 136 of file finfo.c.

{
    PIO_STACK_LOCATION IoStack;
    FILE_INFORMATION_CLASS FileInformationClass;
    PFILE_OBJECT FileObject;
    PMSFS_FCB Fcb;
    PMSFS_CCB Ccb;
    PVOID SystemBuffer;
    ULONG BufferLength;
    NTSTATUS Status;
 
    DPRINT("MsfsSetInformation(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
 
    IoStack = IoGetCurrentIrpStackLocation (Irp);
    FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass;
    FileObject = IoStack->FileObject;
    Fcb = (PMSFS_FCB)FileObject->FsContext;
    Ccb = (PMSFS_CCB)FileObject->FsContext2;
 
    DPRINT("Mailslot name: %wZ\n", &Fcb->Name);
 
    /* setting information is not permitted on client side */
    if (Fcb->ServerCcb != Ccb)
    {
        Status = STATUS_ACCESS_DENIED;
 
        Irp->IoStatus.Status = Status;
        Irp->IoStatus.Information = 0;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return Status;
    }
 
    SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
    BufferLength = IoStack->Parameters.QueryFile.Length;
 
    DPRINT("FileInformationClass %d\n", FileInformationClass);
    DPRINT("SystemBuffer %p\n", SystemBuffer);
 
    switch (FileInformationClass)
    {
    case FileMailslotSetInformation:
        Status = MsfsSetMailslotInformation(Fcb,
                                            SystemBuffer,
                                            &BufferLength);
        break;
 
     default:
        Status = STATUS_NOT_IMPLEMENTED;
    }
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

MsfsTimeout()

VOID NTAPI MsfsTimeout	(	PKDPC	Dpc,
		PVOID	DeferredContext,
		PVOID	SystemArgument1,
		PVOID	SystemArgument2
	)

Definition at line 110 of file msfssup.c.

{
    PMSFS_DPC_CTX Context;
    PIRP Irp;
 
    Context = (PMSFS_DPC_CTX)DeferredContext;
 
    /* Try to get the IRP */
    Irp = IoCsqRemoveIrp(Context->Csq, &Context->CsqContext);
    if (Irp != NULL)
    {
        /* It timed out, complete it (it's ours) and free context */
        Irp->IoStatus.Status = STATUS_IO_TIMEOUT;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        ExFreePoolWithTag(Context, 'NFsM');
    }
    else
    {
        /* We were racing with writing and failed, signal we're done */
        KeSetEvent(&Context->Event, IO_NO_INCREMENT, FALSE);
    }
}

MsfsWrite()

NTSTATUS DEFAULTAPI MsfsWrite	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 132 of file rw.c.

{
    PIO_STACK_LOCATION IoStack;
    PFILE_OBJECT FileObject;
    PMSFS_FCB Fcb;
    PMSFS_CCB Ccb;
    PMSFS_MESSAGE Message;
    KIRQL oldIrql;
    ULONG Length;
    PVOID Buffer;
    PIRP CsqIrp;
    PMSFS_DPC_CTX Context;
 
    DPRINT("MsfsWrite(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
 
    IoStack = IoGetCurrentIrpStackLocation (Irp);
    FileObject = IoStack->FileObject;
    Fcb = (PMSFS_FCB)FileObject->FsContext;
    Ccb = (PMSFS_CCB)FileObject->FsContext2;
 
    DPRINT("MailslotName: %wZ\n", &Fcb->Name);
 
    /* writing is not permitted on server side */
    if (Fcb->ServerCcb == Ccb)
    {
        Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
        Irp->IoStatus.Information = 0;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_ACCESS_DENIED;
    }
 
    Length = IoStack->Parameters.Write.Length;
    if (Irp->MdlAddress)
        Buffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
    else
        Buffer = Irp->UserBuffer;
 
    DPRINT("Length: %lu Message: %s\n", Length, (PUCHAR)Buffer);
 
    /* Allocate new message */
    Message = ExAllocatePoolWithTag(NonPagedPool,
                                    sizeof(MSFS_MESSAGE) + Length,
                                    'rFsM');
    if (Message == NULL)
    {
        Irp->IoStatus.Status = STATUS_NO_MEMORY;
        Irp->IoStatus.Information = 0;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_NO_MEMORY;
    }
 
    Message->Size = Length;
    memcpy(&Message->Buffer, Buffer, Length);
 
    KeAcquireSpinLock(&Fcb->MessageListLock, &oldIrql);
    InsertTailList(&Fcb->MessageListHead, &Message->MessageListEntry);
    Fcb->MessageCount++;
    KeReleaseSpinLock(&Fcb->MessageListLock, oldIrql);
 
    CsqIrp = IoCsqRemoveNextIrp(&Fcb->CancelSafeQueue, NULL);
    if (CsqIrp != NULL)
    {
        /* Get the context */
        Context = CsqIrp->Tail.Overlay.DriverContext[0];
        /* DPC was queued, wait for it to fail (IRP is ours) */
        if (Fcb->TimeOut.QuadPart != -1 && !KeCancelTimer(&Context->Timer))
        {
            KeWaitForSingleObject(&Context->Event, Executive, KernelMode, FALSE, NULL);
        }
 
        /* Free context & attempt read */
        ExFreePoolWithTag(Context, 'NFsM');
        MsfsRead(DeviceObject, CsqIrp);
    }
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = Length;
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}

Variable Documentation

MsfsAcquireLock

IO_CSQ_ACQUIRE_LOCK MsfsAcquireLock

Definition at line 117 of file msfs.h.

Referenced by MsfsCreateMailslot().

MsfsClose

DRIVER_DISPATCH MsfsClose

Definition at line 83 of file msfs.h.

Referenced by DriverEntry().

MsfsCompleteCanceledIrp

IO_CSQ_COMPLETE_CANCELED_IRP MsfsCompleteCanceledIrp

Definition at line 125 of file msfs.h.

Referenced by MsfsCreateMailslot().

MsfsCreate

DRIVER_DISPATCH MsfsCreate

Definition at line 77 of file msfs.h.

Referenced by DriverEntry().

MsfsCreateMailslot

DRIVER_DISPATCH MsfsCreateMailslot

Definition at line 80 of file msfs.h.

Referenced by DriverEntry().

MsfsFileSystemControl

DRIVER_DISPATCH MsfsFileSystemControl

Definition at line 98 of file msfs.h.

Referenced by DriverEntry().

MsfsInsertIrp

IO_CSQ_INSERT_IRP MsfsInsertIrp

Definition at line 105 of file msfs.h.

Referenced by MsfsCreateMailslot().

MsfsPeekNextIrp

IO_CSQ_PEEK_NEXT_IRP MsfsPeekNextIrp

Definition at line 113 of file msfs.h.

Referenced by MsfsCreateMailslot().

MsfsQueryInformation

DRIVER_DISPATCH MsfsQueryInformation

Definition at line 86 of file msfs.h.

Referenced by DriverEntry().

MsfsRead

DRIVER_DISPATCH MsfsRead

Definition at line 92 of file msfs.h.

Referenced by DriverEntry(), and MsfsWrite().

MsfsReleaseLock

IO_CSQ_RELEASE_LOCK MsfsReleaseLock

Definition at line 121 of file msfs.h.

Referenced by MsfsCreateMailslot().

MsfsRemoveIrp

IO_CSQ_REMOVE_IRP MsfsRemoveIrp

Definition at line 109 of file msfs.h.

Referenced by MsfsCreateMailslot().

MsfsSetInformation

DRIVER_DISPATCH MsfsSetInformation

Definition at line 89 of file msfs.h.

Referenced by DriverEntry().

MsfsTimeout

KDEFERRED_ROUTINE MsfsTimeout

Definition at line 129 of file msfs.h.

Referenced by MsfsRead().

MsfsWrite

DRIVER_DISPATCH MsfsWrite

Definition at line 95 of file msfs.h.

Referenced by DriverEntry().