Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-02 02:34:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

- Fixed connection/disconnecting/closing handling, so we don't connect to dead and disconnected pipes.

Browse source 
- Handle the OPEN_EXISTING flag correctly.
- Report reasonable error messages instead of STATUS_UNSUCCESSFUL.

svn path=/trunk/; revision=9097
This commit is contained in:
Filip Navara 2004-04-12 13:03:29 +00:00
parent d7bba47d07
commit de77cb9e79
6 changed files with 206 additions and 186 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

307
reactos/drivers/fs/np/create.c
View file

@ -1,4 +1,4 @@
/* $Id: create.c,v 1.16 2003/06/21 19:55:55 hbirr Exp $
/* $Id: create.c,v 1.17 2004/04/12 13:03:29 navaraf Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
@ -16,10 +16,6 @@
#define NDEBUG
#include <debug.h>
/* GLOBALS *******************************************************************/
/* FUNCTIONS *****************************************************************/
NTSTATUS STDCALL
@ -142,31 +138,14 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
KeUnlockMutex(&DeviceExt->PipeListLock);
#if 0
if (Disposition == OPEN_EXISTING)
{
/* do not connect to listening servers */
FileObject->FsContext = ClientFcb;
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
DPRINT("Success!\n");
return(STATUS_SUCCESS);
}
#endif
/* search for disconnected or listening server fcb */
/* search for listening server fcb */
current_entry = Pipe->ServerFcbListHead.Flink;
while (current_entry != &Pipe->ServerFcbListHead)
{
ServerFcb = CONTAINING_RECORD(current_entry,
NPFS_FCB,
FcbListEntry);
if ((ServerFcb->PipeState == FILE_PIPE_LISTENING_STATE)
|| (ServerFcb->PipeState == FILE_PIPE_DISCONNECTED_STATE))
if (ServerFcb->PipeState == FILE_PIPE_LISTENING_STATE)
{
DPRINT("Server found! Fcb %p\n", ServerFcb);
break;
@ -180,12 +159,18 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
FileObject->FsContext = ClientFcb;
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return(STATUS_SUCCESS);
if (Disposition == FILE_OPEN)
{
Irp->IoStatus.Status = STATUS_PIPE_BUSY;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_PIPE_BUSY;
}
else
{
Irp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
}
ClientFcb->OtherSide = ServerFcb;
@ -234,102 +219,151 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
Buffer = (PIO_PIPE_CREATE_BUFFER)Irp->Tail.Overlay.AuxiliaryBuffer;
Pipe = ExAllocatePool(NonPagedPool, sizeof(NPFS_PIPE));
if (Pipe == NULL)
{
Irp->IoStatus.Status = STATUS_NO_MEMORY;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return(STATUS_NO_MEMORY);
}
Irp->IoStatus.Information = 0;
Fcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_FCB));
if (Fcb == NULL)
{
ExFreePool(Pipe);
Irp->IoStatus.Status = STATUS_NO_MEMORY;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return(STATUS_NO_MEMORY);
return STATUS_NO_MEMORY;
}
if (RtlCreateUnicodeString(&Pipe->PipeName, FileObject->FileName.Buffer) == 0)
{
ExFreePool(Pipe);
ExFreePool(Fcb);
Irp->IoStatus.Status = STATUS_NO_MEMORY;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
KeLockMutex(&DeviceExt->PipeListLock);
return(STATUS_NO_MEMORY);
}
/*
* First search for existing Pipe with the same name.
*/
Pipe->ReferenceCount = 0;
InitializeListHead(&Pipe->ServerFcbListHead);
InitializeListHead(&Pipe->ClientFcbListHead);
KeInitializeSpinLock(&Pipe->FcbListLock);
Pipe->PipeType = Buffer->WriteModeMessage ? FILE_PIPE_MESSAGE_TYPE : FILE_PIPE_BYTE_STREAM_TYPE;
Pipe->PipeWriteMode = Buffer->WriteModeMessage ? FILE_PIPE_MESSAGE_MODE : FILE_PIPE_BYTE_STREAM_MODE;
Pipe->PipeReadMode = Buffer->ReadModeMessage ? FILE_PIPE_MESSAGE_MODE : FILE_PIPE_BYTE_STREAM_MODE;
Pipe->PipeBlockMode = Buffer->NonBlocking;
Pipe->PipeConfiguration = IoStack->Parameters.Create.Options & 0x3;
Pipe->MaximumInstances = Buffer->MaxInstances;
Pipe->CurrentInstances = 0;
Pipe->TimeOut = Buffer->TimeOut;
if (!(IoStack->Parameters.Create.Options & FILE_PIPE_OUTBOUND) ||
IoStack->Parameters.Create.Options & FILE_PIPE_FULL_DUPLEX)
current_entry = DeviceExt->PipeListHead.Flink;
while (current_entry != &DeviceExt->PipeListHead)
{
if (Buffer->InBufferSize == 0)
current = CONTAINING_RECORD(current_entry,
NPFS_PIPE,
PipeListEntry);
if (RtlCompareUnicodeString(&FileObject->FileName, &current->PipeName, TRUE) == 0)
{
break;
}
current_entry = current_entry->Flink;
}
if (current_entry != &DeviceExt->PipeListHead)
{
/*
* Found Pipe with the same name. Check if we are
* allowed to use it.
*/
Pipe = current;
KeUnlockMutex(&DeviceExt->PipeListLock);
if (Pipe->CurrentInstances >= Pipe->MaximumInstances)
{
Pipe->InboundQuota = DeviceExt->DefaultQuota;
ExFreePool(Fcb);
Irp->IoStatus.Status = STATUS_PIPE_BUSY;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_PIPE_BUSY;
}
else
/* FIXME: Check pipe modes also! */
if (Pipe->MaximumInstances != Buffer->MaxInstances ||
Pipe->TimeOut.QuadPart != Buffer->TimeOut.QuadPart)
{
Pipe->InboundQuota = PAGE_ROUND_UP(Buffer->InBufferSize);
if (Pipe->InboundQuota < DeviceExt->MinQuota)
{
Pipe->InboundQuota = DeviceExt->MinQuota;
}
else if (Pipe->InboundQuota > DeviceExt->MaxQuota)
{
Pipe->InboundQuota = DeviceExt->MaxQuota;
}
}
ExFreePool(Fcb);
Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_ACCESS_DENIED;
}
}
else
{
Pipe->InboundQuota = 0;
}
if (IoStack->Parameters.Create.Options & (FILE_PIPE_FULL_DUPLEX|FILE_PIPE_OUTBOUND))
{
if (Buffer->OutBufferSize == 0)
Pipe = ExAllocatePool(NonPagedPool, sizeof(NPFS_PIPE));
if (Pipe == NULL)
{
Pipe->OutboundQuota = DeviceExt->DefaultQuota;
KeUnlockMutex(&DeviceExt->PipeListLock);
Irp->IoStatus.Status = STATUS_NO_MEMORY;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NO_MEMORY;
}
if (RtlCreateUnicodeString(&Pipe->PipeName, FileObject->FileName.Buffer) == 0)
{
KeUnlockMutex(&DeviceExt->PipeListLock);
ExFreePool(Pipe);
ExFreePool(Fcb);
Irp->IoStatus.Status = STATUS_NO_MEMORY;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return(STATUS_NO_MEMORY);
}
Pipe->ReferenceCount = 0;
InitializeListHead(&Pipe->ServerFcbListHead);
InitializeListHead(&Pipe->ClientFcbListHead);
KeInitializeSpinLock(&Pipe->FcbListLock);
Pipe->PipeType = Buffer->WriteModeMessage ? FILE_PIPE_MESSAGE_TYPE : FILE_PIPE_BYTE_STREAM_TYPE;
Pipe->PipeWriteMode = Buffer->WriteModeMessage ? FILE_PIPE_MESSAGE_MODE : FILE_PIPE_BYTE_STREAM_MODE;
Pipe->PipeReadMode = Buffer->ReadModeMessage ? FILE_PIPE_MESSAGE_MODE : FILE_PIPE_BYTE_STREAM_MODE;
Pipe->PipeBlockMode = Buffer->NonBlocking;
Pipe->PipeConfiguration = IoStack->Parameters.Create.Options & 0x3;
Pipe->MaximumInstances = Buffer->MaxInstances;
Pipe->CurrentInstances = 0;
Pipe->TimeOut = Buffer->TimeOut;
if (!(IoStack->Parameters.Create.Options & FILE_PIPE_OUTBOUND) ||
IoStack->Parameters.Create.Options & FILE_PIPE_FULL_DUPLEX)
{
if (Buffer->InBufferSize == 0)
{
Pipe->InboundQuota = DeviceExt->DefaultQuota;
}
else
{
Pipe->InboundQuota = PAGE_ROUND_UP(Buffer->InBufferSize);
if (Pipe->InboundQuota < DeviceExt->MinQuota)
{
Pipe->InboundQuota = DeviceExt->MinQuota;
}
else if (Pipe->InboundQuota > DeviceExt->MaxQuota)
{
Pipe->InboundQuota = DeviceExt->MaxQuota;
}
}
}
else
{
Pipe->OutboundQuota = PAGE_ROUND_UP(Buffer->OutBufferSize);
if (Pipe->OutboundQuota < DeviceExt->MinQuota)
Pipe->InboundQuota = 0;
}
if (IoStack->Parameters.Create.Options & (FILE_PIPE_FULL_DUPLEX|FILE_PIPE_OUTBOUND))
{
if (Buffer->OutBufferSize == 0)
{
Pipe->OutboundQuota = DeviceExt->MinQuota;
Pipe->OutboundQuota = DeviceExt->DefaultQuota;
}
else if (Pipe->OutboundQuota > DeviceExt->MaxQuota)
else
{
Pipe->OutboundQuota = DeviceExt->MaxQuota;
}
}
}
else
{
Pipe->OutboundQuota = 0;
Pipe->OutboundQuota = PAGE_ROUND_UP(Buffer->OutBufferSize);
if (Pipe->OutboundQuota < DeviceExt->MinQuota)
{
Pipe->OutboundQuota = DeviceExt->MinQuota;
}
else if (Pipe->OutboundQuota > DeviceExt->MaxQuota)
{
Pipe->OutboundQuota = DeviceExt->MaxQuota;
}
}
}
else
{
Pipe->OutboundQuota = 0;
}
InsertTailList(&DeviceExt->PipeListHead, &Pipe->PipeListEntry);
KeUnlockMutex(&DeviceExt->PipeListLock);
}
if (Pipe->OutboundQuota)
@ -338,17 +372,17 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
if (Fcb->Data == NULL)
{
ExFreePool(Fcb);
RtlFreeUnicodeString(&Pipe->PipeName);
ExFreePool(Pipe);
if (Pipe != current)
{
RtlFreeUnicodeString(&Pipe->PipeName);
ExFreePool(Pipe);
}
Irp->IoStatus.Status = STATUS_NO_MEMORY;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return(STATUS_NO_MEMORY);
return STATUS_NO_MEMORY;
}
}
else
{
@ -362,34 +396,6 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
Fcb->MaxDataLength = Pipe->OutboundQuota;
KeInitializeSpinLock(&Fcb->DataListLock);
KeLockMutex(&DeviceExt->PipeListLock);
current_entry = DeviceExt->PipeListHead.Flink;
while (current_entry != &DeviceExt->PipeListHead)
{
current = CONTAINING_RECORD(current_entry,
NPFS_PIPE,
PipeListEntry);
if (RtlCompareUnicodeString(&Pipe->PipeName, &current->PipeName, TRUE) == 0)
{
break;
}
current_entry = current_entry->Flink;
}
if (current_entry != &DeviceExt->PipeListHead)
{
RtlFreeUnicodeString(&Pipe->PipeName);
ExFreePool(Pipe);
Pipe = current;
}
else
{
InsertTailList(&DeviceExt->PipeListHead, &Pipe->PipeListEntry);
}
Pipe->ReferenceCount++;
Pipe->CurrentInstances++;
@ -399,8 +405,8 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
Fcb->Pipe = Pipe;
Fcb->PipeEnd = FILE_PIPE_SERVER_END;
Fcb->PipeState = FILE_PIPE_LISTENING_STATE;
Fcb->OtherSide = NULL;
Fcb->PipeState = FILE_PIPE_DISCONNECTED_STATE;
KeInitializeEvent(&Fcb->ConnectEvent,
SynchronizationEvent,
@ -409,15 +415,10 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
KeInitializeEvent(&Fcb->Event,
SynchronizationEvent,
FALSE);
KeUnlockMutex(&DeviceExt->PipeListLock);
FileObject->FsContext = Fcb;
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return(STATUS_SUCCESS);
@ -459,7 +460,6 @@ NpfsClose(PDEVICE_OBJECT DeviceObject,
KeLockMutex(&DeviceExt->PipeListLock);
if (Fcb->PipeEnd == FILE_PIPE_SERVER_END)
{
/* FIXME: Clean up existing connections here ?? */
@ -475,9 +475,10 @@ NpfsClose(PDEVICE_OBJECT DeviceObject,
*/
KeSetEvent(&Fcb->OtherSide->Event, IO_NO_INCREMENT, FALSE);
}
Fcb->PipeState = FILE_PIPE_DISCONNECTED_STATE;
Fcb->PipeState = 0;
}
}
Pipe->ReferenceCount--;
if (Fcb->PipeEnd == FILE_PIPE_CLIENT_END)
@ -494,19 +495,25 @@ NpfsClose(PDEVICE_OBJECT DeviceObject,
*/
KeSetEvent(&Fcb->OtherSide->Event, IO_NO_INCREMENT, FALSE);
}
Fcb->PipeState = FILE_PIPE_DISCONNECTED_STATE;
Fcb->PipeState = 0;
}
}
FileObject->FsContext = NULL;
#if 0
DPRINT("%x\n", Pipe->ReferenceCount);
if (Pipe->ReferenceCount == 0)
#else
if (Fcb->PipeEnd == FILE_PIPE_SERVER_END &&
Fcb->Pipe->CurrentInstances == 0)
#endif
{
KeAcquireSpinLock(&Pipe->FcbListLock, &oldIrql);
if (Fcb->OtherSide)
{
RemoveEntryList(&Fcb->OtherSide->FcbListEntry);
}
{
RemoveEntryList(&Fcb->OtherSide->FcbListEntry);
}
RemoveEntryList(&Fcb->FcbListEntry);
KeReleaseSpinLock(&Pipe->FcbListLock, oldIrql);
if (Fcb->OtherSide)

5
reactos/drivers/fs/np/finfo.c
View file

@ -1,4 +1,4 @@
/* $Id: finfo.c,v 1.5 2002/09/08 10:22:11 chorns Exp $
/* $Id: finfo.c,v 1.6 2004/04/12 13:03:29 navaraf Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
@ -15,9 +15,6 @@
#define NDEBUG
#include <debug.h>
/* FUNCTIONS *****************************************************************/
static NTSTATUS

51
reactos/drivers/fs/np/fsctrl.c
View file

@ -1,4 +1,4 @@
/* $Id: fsctrl.c,v 1.13 2003/11/13 15:26:07 ekohl Exp $
/* $Id: fsctrl.c,v 1.14 2004/04/12 13:03:29 navaraf Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
@ -16,7 +16,6 @@
#define NDEBUG
#include <debug.h>
/* FUNCTIONS *****************************************************************/
static NTSTATUS
@ -26,6 +25,7 @@ NpfsConnectPipe(PNPFS_FCB Fcb)
PLIST_ENTRY current_entry;
PNPFS_FCB ClientFcb;
NTSTATUS Status;
KIRQL oldIrql;
DPRINT("NpfsConnectPipe()\n");
@ -35,19 +35,13 @@ NpfsConnectPipe(PNPFS_FCB Fcb)
if (Fcb->PipeState == FILE_PIPE_CLOSING_STATE)
return STATUS_PIPE_CLOSING;
/*
* Acceptable states are: FILE_PIPE_DISCONNECTED_STATE and
* FILE_PIPE_LISTENING_STATE
*/
DPRINT("Waiting for connection...\n");
Pipe = Fcb->Pipe;
Fcb->PipeState = FILE_PIPE_LISTENING_STATE;
/* search for a listening client fcb */
KeAcquireSpinLock(&Pipe->FcbListLock, &oldIrql);
current_entry = Pipe->ClientFcbListHead.Flink;
while (current_entry != &Pipe->ClientFcbListHead)
{
@ -55,8 +49,7 @@ NpfsConnectPipe(PNPFS_FCB Fcb)
NPFS_FCB,
FcbListEntry);
if ((ClientFcb->PipeState == FILE_PIPE_LISTENING_STATE)
|| (ClientFcb->PipeState == FILE_PIPE_DISCONNECTED_STATE))
if (ClientFcb->PipeState == FILE_PIPE_LISTENING_STATE)
{
break;
}
@ -64,8 +57,7 @@ NpfsConnectPipe(PNPFS_FCB Fcb)
current_entry = current_entry->Flink;
}
if ((current_entry != &Pipe->ClientFcbListHead)
&& (ClientFcb->PipeState == FILE_PIPE_LISTENING_STATE))
if (current_entry != &Pipe->ClientFcbListHead)
{
/* found a listening client fcb */
DPRINT("Listening client fcb found -- connecting\n");
@ -78,25 +70,23 @@ NpfsConnectPipe(PNPFS_FCB Fcb)
Fcb->PipeState = FILE_PIPE_CONNECTED_STATE;
ClientFcb->PipeState = FILE_PIPE_CONNECTED_STATE;
KeReleaseSpinLock(&Pipe->FcbListLock, oldIrql);
/* FIXME: create and initialize data queues */
/* signal client's connect event */
KeSetEvent(&ClientFcb->ConnectEvent, IO_NO_INCREMENT, FALSE);
}
else if ((current_entry != &Pipe->ClientFcbListHead)
&& (ClientFcb->PipeState == FILE_PIPE_DISCONNECTED_STATE))
{
/* found a disconnected client fcb */
DPRINT("Disconnected client fcb found - notifying client\n");
/* signal client's connect event */
KeSetEvent(&ClientFcb->ConnectEvent, IO_NO_INCREMENT, FALSE);
}
else
{
/* no listening client fcb found */
DPRINT("No listening client fcb found -- waiting for client\n");
KeReleaseSpinLock(&Pipe->FcbListLock, oldIrql);
Fcb->PipeState = FILE_PIPE_LISTENING_STATE;
Status = KeWaitForSingleObject(&Fcb->ConnectEvent,
UserRequest,
KernelMode,
@ -496,7 +486,7 @@ NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
break;
default:
DPRINT("IoControlCode: %x\n", IoStack->Parameters.FileSystemControl.IoControlCode)
DPRINT("IoControlCode: %x\n", IoStack->Parameters.FileSystemControl.FsControlCode)
Status = STATUS_UNSUCCESSFUL;
}
@ -508,4 +498,19 @@ NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
return(Status);
}
NTSTATUS STDCALL
NpfsFlushBuffers(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
/* FIXME: Implement */
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
/* EOF */

4
reactos/drivers/fs/np/npfs.c
View file

@ -1,4 +1,4 @@
/* $Id: npfs.c,v 1.9 2004/03/07 20:33:25 navaraf Exp $
/* $Id: npfs.c,v 1.10 2004/04/12 13:03:29 navaraf Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
@ -41,7 +41,7 @@ DriverEntry(PDRIVER_OBJECT DriverObject,
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] =
NpfsQueryVolumeInformation;
// DriverObject->MajorFunction[IRP_MJ_CLEANUP] = NpfsCleanup;
// DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = NpfsFlushBuffers;
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = NpfsFlushBuffers;
// DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] =
// NpfsDirectoryControl;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] =

4
reactos/drivers/fs/np/npfs.h
View file

@ -1,4 +1,4 @@
/* $Id: npfs.h,v 1.14 2003/06/21 19:55:55 hbirr Exp $ */
/* $Id: npfs.h,v 1.15 2004/04/12 13:03:29 navaraf Exp $ */
#ifndef __SERVICES_FS_NP_NPFS_H
#define __SERVICES_FS_NP_NPFS_H
@ -75,6 +75,8 @@ NTSTATUS STDCALL NpfsClose(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS STDCALL NpfsRead(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS STDCALL NpfsWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS STDCALL NpfsFlushBuffers(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS STDCALL NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS STDCALL NpfsQueryInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp);

21
reactos/drivers/fs/np/rw.c
View file

@ -1,4 +1,4 @@
/* $Id: rw.c,v 1.11 2004/04/10 16:20:59 navaraf Exp $
/* $Id: rw.c,v 1.12 2004/04/12 13:03:29 navaraf Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
@ -16,10 +16,8 @@
#define NDEBUG
#include <debug.h>
/* FUNCTIONS *****************************************************************/
NTSTATUS STDCALL
NpfsRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
@ -49,7 +47,12 @@ NpfsRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
if (ReadFcb == NULL)
{
DPRINT("Pipe is NOT connected!\n");
Status = STATUS_UNSUCCESSFUL;
if (Fcb->PipeState == FILE_PIPE_LISTENING_STATE)
Status = STATUS_PIPE_LISTENING;
else if (Fcb->PipeState == FILE_PIPE_DISCONNECTED_STATE)
Status = STATUS_PIPE_DISCONNECTED;
else
Status = STATUS_UNSUCCESSFUL;
Information = 0;
goto done;
}
@ -92,6 +95,7 @@ NpfsRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
}
if (Fcb->PipeState != FILE_PIPE_CONNECTED_STATE)
{
DPRINT("PipeState: %x\n", Fcb->PipeState);
Status = STATUS_PIPE_BROKEN;
goto done;
}
@ -223,7 +227,7 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
if (Irp->MdlAddress == NULL)
{
DbgPrint ("Irp->MdlAddress == NULL\n");
DPRINT("Irp->MdlAddress == NULL\n");
Status = STATUS_UNSUCCESSFUL;
Length = 0;
goto done;
@ -232,7 +236,12 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
if (Fcb->OtherSide == NULL)
{
DPRINT("Pipe is NOT connected!\n");
Status = STATUS_UNSUCCESSFUL;
if (Fcb->PipeState == FILE_PIPE_LISTENING_STATE)
Status = STATUS_PIPE_LISTENING;
else if (Fcb->PipeState == FILE_PIPE_DISCONNECTED_STATE)
Status = STATUS_PIPE_DISCONNECTED;
else
Status = STATUS_UNSUCCESSFUL;
Length = 0;
goto done;
}