Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-08-01 17:11:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

The NPFS_FCB struct is actually a CCB (Context Control Block) instead of an FCB (File Control Block). Rename it accordingly and store pointers to it in FileObject->FsContext2 instead of FileObject->FsContext.

Browse source 
svn path=/trunk/; revision=21845
This commit is contained in:
Eric Kohl 2006-05-07 19:56:32 +00:00
parent 3d1978b003
commit 8ee8c5c694
5 changed files with 415 additions and 399 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

280
reactos/drivers/filesystems/np/create.c
View file

@ -41,7 +41,7 @@ NpfsFindPipe(PNPFS_DEVICE_EXTENSION DeviceExt,
} }
static PNPFS_FCB static PNPFS_CCB
NpfsFindListeningServerInstance(PNPFS_PIPE Pipe) NpfsFindListeningServerInstance(PNPFS_PIPE Pipe)
{ {
PLIST_ENTRY CurrentEntry; PLIST_ENTRY CurrentEntry;
@ -54,16 +54,16 @@ NpfsFindListeningServerInstance(PNPFS_PIPE Pipe)
{ {
Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry); Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry);
Irp = CONTAINING_RECORD(Waiter, IRP, Tail.Overlay.DriverContext); Irp = CONTAINING_RECORD(Waiter, IRP, Tail.Overlay.DriverContext);
if (Waiter->Fcb->PipeState == FILE_PIPE_LISTENING_STATE) if (Waiter->Ccb->PipeState == FILE_PIPE_LISTENING_STATE)
{ {
DPRINT("Server found! Fcb %p\n", Waiter->Fcb); DPRINT("Server found! CCB %p\n", Waiter->Ccb);
IoAcquireCancelSpinLock(&oldIrql); IoAcquireCancelSpinLock(&oldIrql);
if (!Irp->Cancel) if (!Irp->Cancel)
{ {
(void)IoSetCancelRoutine(Irp, NULL); (void)IoSetCancelRoutine(Irp, NULL);
IoReleaseCancelSpinLock(oldIrql); IoReleaseCancelSpinLock(oldIrql);
return Waiter->Fcb; return Waiter->Ccb;
} }
IoReleaseCancelSpinLock(oldIrql); IoReleaseCancelSpinLock(oldIrql);
} }
@ -77,7 +77,7 @@ NpfsFindListeningServerInstance(PNPFS_PIPE Pipe)
static VOID static VOID
NpfsSignalAndRemoveListeningServerInstance(PNPFS_PIPE Pipe, NpfsSignalAndRemoveListeningServerInstance(PNPFS_PIPE Pipe,
PNPFS_FCB Fcb) PNPFS_CCB Ccb)
{ {
PLIST_ENTRY CurrentEntry; PLIST_ENTRY CurrentEntry;
PNPFS_WAITER_ENTRY Waiter; PNPFS_WAITER_ENTRY Waiter;
@ -87,9 +87,9 @@ NpfsSignalAndRemoveListeningServerInstance(PNPFS_PIPE Pipe,
while (CurrentEntry != &Pipe->WaiterListHead) while (CurrentEntry != &Pipe->WaiterListHead)
{ {
Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry); Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry);
if (Waiter->Fcb == Fcb) if (Waiter->Ccb == Ccb)
{ {
DPRINT("Server found! Fcb %p\n", Waiter->Fcb); DPRINT("Server found! CCB %p\n", Waiter->Ccb);
RemoveEntryList(&Waiter->Entry); RemoveEntryList(&Waiter->Entry);
Irp = CONTAINING_RECORD(Waiter, IRP, Tail.Overlay.DriverContext); Irp = CONTAINING_RECORD(Waiter, IRP, Tail.Overlay.DriverContext);
@ -110,8 +110,8 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
PEXTENDED_IO_STACK_LOCATION IoStack; PEXTENDED_IO_STACK_LOCATION IoStack;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNPFS_PIPE Pipe; PNPFS_PIPE Pipe;
PNPFS_FCB ClientFcb; PNPFS_CCB ClientCcb;
PNPFS_FCB ServerFcb = NULL; PNPFS_CCB ServerCcb = NULL;
PNPFS_DEVICE_EXTENSION DeviceExt; PNPFS_DEVICE_EXTENSION DeviceExt;
BOOLEAN SpecialAccess; BOOLEAN SpecialAccess;
ACCESS_MASK DesiredAccess; ACCESS_MASK DesiredAccess;
@ -152,42 +152,42 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
KeUnlockMutex(&DeviceExt->PipeListLock); KeUnlockMutex(&DeviceExt->PipeListLock);
/* /*
* Acquire the lock for FCB lists. From now on no modifications to the * Acquire the lock for CCB lists. From now on no modifications to the
* FCB lists are allowed, because it can cause various misconsistencies. * CCB lists are allowed, because it can cause various misconsistencies.
*/ */
KeLockMutex(&Pipe->FcbListLock); KeLockMutex(&Pipe->CcbListLock);
/* /*
* Step 2. Create the client FCB. * Step 2. Create the client CCB.
*/ */
ClientFcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_FCB)); ClientCcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_CCB));
if (ClientFcb == NULL) if (ClientCcb == NULL)
{ {
DPRINT("No memory!\n"); DPRINT("No memory!\n");
KeUnlockMutex(&Pipe->FcbListLock); KeUnlockMutex(&Pipe->CcbListLock);
Irp->IoStatus.Status = STATUS_NO_MEMORY; Irp->IoStatus.Status = STATUS_NO_MEMORY;
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
ClientFcb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread; ClientCcb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread;
ClientFcb->Pipe = Pipe; ClientCcb->Pipe = Pipe;
ClientFcb->PipeEnd = FILE_PIPE_CLIENT_END; ClientCcb->PipeEnd = FILE_PIPE_CLIENT_END;
ClientFcb->OtherSide = NULL; ClientCcb->OtherSide = NULL;
ClientFcb->PipeState = SpecialAccess ? 0 : FILE_PIPE_DISCONNECTED_STATE; ClientCcb->PipeState = SpecialAccess ? 0 : FILE_PIPE_DISCONNECTED_STATE;
InitializeListHead(&ClientFcb->ReadRequestListHead); InitializeListHead(&ClientCcb->ReadRequestListHead);
DPRINT("Fcb: %x\n", ClientFcb); DPRINT("CCB: %p\n", ClientCcb);
/* Initialize data list. */ /* Initialize data list. */
if (Pipe->OutboundQuota) if (Pipe->OutboundQuota)
{ {
ClientFcb->Data = ExAllocatePool(PagedPool, Pipe->OutboundQuota); ClientCcb->Data = ExAllocatePool(PagedPool, Pipe->OutboundQuota);
if (ClientFcb->Data == NULL) if (ClientCcb->Data == NULL)
{ {
DPRINT("No memory!\n"); DPRINT("No memory!\n");
ExFreePool(ClientFcb); ExFreePool(ClientCcb);
KeUnlockMutex(&Pipe->FcbListLock); KeUnlockMutex(&Pipe->CcbListLock);
Irp->IoStatus.Status = STATUS_NO_MEMORY; Irp->IoStatus.Status = STATUS_NO_MEMORY;
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
@ -195,50 +195,50 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
} }
else else
{ {
ClientFcb->Data = NULL; ClientCcb->Data = NULL;
} }
ClientFcb->ReadPtr = ClientFcb->Data; ClientCcb->ReadPtr = ClientCcb->Data;
ClientFcb->WritePtr = ClientFcb->Data; ClientCcb->WritePtr = ClientCcb->Data;
ClientFcb->ReadDataAvailable = 0; ClientCcb->ReadDataAvailable = 0;
ClientFcb->WriteQuotaAvailable = Pipe->OutboundQuota; ClientCcb->WriteQuotaAvailable = Pipe->OutboundQuota;
ClientFcb->MaxDataLength = Pipe->OutboundQuota; ClientCcb->MaxDataLength = Pipe->OutboundQuota;
ExInitializeFastMutex(&ClientFcb->DataListLock); ExInitializeFastMutex(&ClientCcb->DataListLock);
KeInitializeEvent(&ClientFcb->ConnectEvent, SynchronizationEvent, FALSE); KeInitializeEvent(&ClientCcb->ConnectEvent, SynchronizationEvent, FALSE);
KeInitializeEvent(&ClientFcb->ReadEvent, SynchronizationEvent, FALSE); KeInitializeEvent(&ClientCcb->ReadEvent, SynchronizationEvent, FALSE);
KeInitializeEvent(&ClientFcb->WriteEvent, SynchronizationEvent, FALSE); KeInitializeEvent(&ClientCcb->WriteEvent, SynchronizationEvent, FALSE);
/* /*
* Step 3. Search for listening server FCB. * Step 3. Search for listening server CCB.
*/ */
if (!SpecialAccess) if (!SpecialAccess)
{ {
/* /*
* WARNING: Point of no return! Once we get the server FCB it's * 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 * possible that we completed a wait request and so we have to
* complete even this request. * complete even this request.
*/ */
ServerFcb = NpfsFindListeningServerInstance(Pipe); ServerCcb = NpfsFindListeningServerInstance(Pipe);
if (ServerFcb == NULL) if (ServerCcb == NULL)
{ {
PLIST_ENTRY CurrentEntry; PLIST_ENTRY CurrentEntry;
PNPFS_FCB Fcb; PNPFS_CCB Ccb;
/* /*
* If no waiting server FCB was found then try to pick * If no waiting server CCB was found then try to pick
* one of the listing server FCB on the pipe. * one of the listing server CCB on the pipe.
*/ */
CurrentEntry = Pipe->ServerFcbListHead.Flink; CurrentEntry = Pipe->ServerCcbListHead.Flink;
while (CurrentEntry != &Pipe->ServerFcbListHead) while (CurrentEntry != &Pipe->ServerCcbListHead)
{ {
Fcb = CONTAINING_RECORD(CurrentEntry, NPFS_FCB, FcbListEntry); Ccb = CONTAINING_RECORD(CurrentEntry, NPFS_CCB, CcbListEntry);
if (Fcb->PipeState == FILE_PIPE_LISTENING_STATE) if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE)
{ {
ServerFcb = Fcb; ServerCcb = Ccb;
break; break;
} }
CurrentEntry = CurrentEntry->Flink; CurrentEntry = CurrentEntry->Flink;
@ -248,13 +248,13 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
* No one is listening to me?! I'm so lonely... :( * No one is listening to me?! I'm so lonely... :(
*/ */
if (ServerFcb == NULL) if (ServerCcb == NULL)
{ {
/* Not found, bail out with error for FILE_OPEN requests. */ /* Not found, bail out with error for FILE_OPEN requests. */
DPRINT("No listening server fcb found!\n"); DPRINT("No listening server CCB found!\n");
if (ClientFcb->Data) if (ClientCcb->Data)
ExFreePool(ClientFcb->Data); ExFreePool(ClientCcb->Data);
KeUnlockMutex(&Pipe->FcbListLock); KeUnlockMutex(&Pipe->CcbListLock);
Irp->IoStatus.Status = STATUS_PIPE_BUSY; Irp->IoStatus.Status = STATUS_PIPE_BUSY;
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_PIPE_BUSY; return STATUS_PIPE_BUSY;
@ -264,37 +264,37 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
{ {
/* Signal the server thread and remove it from the waiter list */ /* Signal the server thread and remove it from the waiter list */
/* FIXME: Merge this with the NpfsFindListeningServerInstance routine. */ /* FIXME: Merge this with the NpfsFindListeningServerInstance routine. */
NpfsSignalAndRemoveListeningServerInstance(Pipe, ServerFcb); NpfsSignalAndRemoveListeningServerInstance(Pipe, ServerCcb);
} }
} }
else if (IsListEmpty(&Pipe->ServerFcbListHead)) else if (IsListEmpty(&Pipe->ServerCcbListHead))
{ {
DPRINT("No server fcb found!\n"); DPRINT("No server fcb found!\n");
KeUnlockMutex(&Pipe->FcbListLock); KeUnlockMutex(&Pipe->CcbListLock);
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL; Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
/* /*
* Step 4. Add the client FCB to a list and connect it if possible. * Step 4. Add the client CCB to a list and connect it if possible.
*/ */
/* Add the client FCB to the pipe FCB list. */ /* Add the client CCB to the pipe CCB list. */
InsertTailList(&Pipe->ClientFcbListHead, &ClientFcb->FcbListEntry); InsertTailList(&Pipe->ClientCcbListHead, &ClientCcb->CcbListEntry);
/* Connect to listening server side */ /* Connect to listening server side */
if (ServerFcb) if (ServerCcb)
{ {
ClientFcb->OtherSide = ServerFcb; ClientCcb->OtherSide = ServerCcb;
ServerFcb->OtherSide = ClientFcb; ServerCcb->OtherSide = ClientCcb;
ClientFcb->PipeState = FILE_PIPE_CONNECTED_STATE; ClientCcb->PipeState = FILE_PIPE_CONNECTED_STATE;
ServerFcb->PipeState = FILE_PIPE_CONNECTED_STATE; ServerCcb->PipeState = FILE_PIPE_CONNECTED_STATE;
} }
KeUnlockMutex(&Pipe->FcbListLock); KeUnlockMutex(&Pipe->CcbListLock);
FileObject->FsContext = ClientFcb; FileObject->FsContext2 = ClientCcb;
FileObject->Flags |= FO_NAMED_PIPE; FileObject->Flags |= FO_NAMED_PIPE;
Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Status = STATUS_SUCCESS;
@ -314,7 +314,7 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNPFS_DEVICE_EXTENSION DeviceExt; PNPFS_DEVICE_EXTENSION DeviceExt;
PNPFS_PIPE Pipe; PNPFS_PIPE Pipe;
PNPFS_FCB Fcb; PNPFS_CCB Ccb;
PNAMED_PIPE_CREATE_PARAMETERS Buffer; PNAMED_PIPE_CREATE_PARAMETERS Buffer;
BOOLEAN NewPipe = FALSE; BOOLEAN NewPipe = FALSE;
@ -338,15 +338,15 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
Fcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_FCB)); Ccb = ExAllocatePool(NonPagedPool, sizeof(NPFS_CCB));
if (Fcb == NULL) if (Ccb == NULL)
{ {
Irp->IoStatus.Status = STATUS_NO_MEMORY; Irp->IoStatus.Status = STATUS_NO_MEMORY;
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
Fcb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread; Ccb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread;
KeLockMutex(&DeviceExt->PipeListLock); KeLockMutex(&DeviceExt->PipeListLock);
/* /*
@ -365,7 +365,7 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
if (Pipe->CurrentInstances >= Pipe->MaximumInstances) if (Pipe->CurrentInstances >= Pipe->MaximumInstances)
{ {
DPRINT("Out of instances.\n"); DPRINT("Out of instances.\n");
ExFreePool(Fcb); ExFreePool(Ccb);
Irp->IoStatus.Status = STATUS_PIPE_BUSY; Irp->IoStatus.Status = STATUS_PIPE_BUSY;
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_PIPE_BUSY; return STATUS_PIPE_BUSY;
@ -376,7 +376,7 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
Pipe->TimeOut.QuadPart != Buffer->DefaultTimeout.QuadPart) Pipe->TimeOut.QuadPart != Buffer->DefaultTimeout.QuadPart)
{ {
DPRINT("Asked for invalid pipe mode.\n"); DPRINT("Asked for invalid pipe mode.\n");
ExFreePool(Fcb); ExFreePool(Ccb);
Irp->IoStatus.Status = STATUS_ACCESS_DENIED; Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_ACCESS_DENIED; return STATUS_ACCESS_DENIED;
@ -402,7 +402,7 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
{ {
KeUnlockMutex(&DeviceExt->PipeListLock); KeUnlockMutex(&DeviceExt->PipeListLock);
ExFreePool(Pipe); ExFreePool(Pipe);
ExFreePool(Fcb); ExFreePool(Ccb);
Irp->IoStatus.Status = STATUS_NO_MEMORY; Irp->IoStatus.Status = STATUS_NO_MEMORY;
Irp->IoStatus.Information = 0; Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
@ -411,10 +411,10 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
RtlCopyUnicodeString(&Pipe->PipeName, &FileObject->FileName); RtlCopyUnicodeString(&Pipe->PipeName, &FileObject->FileName);
InitializeListHead(&Pipe->ServerFcbListHead); InitializeListHead(&Pipe->ServerCcbListHead);
InitializeListHead(&Pipe->ClientFcbListHead); InitializeListHead(&Pipe->ClientCcbListHead);
InitializeListHead(&Pipe->WaiterListHead); InitializeListHead(&Pipe->WaiterListHead);
KeInitializeMutex(&Pipe->FcbListLock, 0); KeInitializeMutex(&Pipe->CcbListLock, 0);
Pipe->PipeType = Buffer->NamedPipeType; Pipe->PipeType = Buffer->NamedPipeType;
Pipe->WriteMode = Buffer->ReadMode; Pipe->WriteMode = Buffer->ReadMode;
@ -490,10 +490,10 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
if (Pipe->InboundQuota) if (Pipe->InboundQuota)
{ {
Fcb->Data = ExAllocatePool(PagedPool, Pipe->InboundQuota); Ccb->Data = ExAllocatePool(PagedPool, Pipe->InboundQuota);
if (Fcb->Data == NULL) if (Ccb->Data == NULL)
{ {
ExFreePool(Fcb); ExFreePool(Ccb);
if (NewPipe) if (NewPipe)
{ {
@ -511,35 +511,35 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
} }
else else
{ {
Fcb->Data = NULL; Ccb->Data = NULL;
} }
Fcb->ReadPtr = Fcb->Data; Ccb->ReadPtr = Ccb->Data;
Fcb->WritePtr = Fcb->Data; Ccb->WritePtr = Ccb->Data;
Fcb->ReadDataAvailable = 0; Ccb->ReadDataAvailable = 0;
Fcb->WriteQuotaAvailable = Pipe->InboundQuota; Ccb->WriteQuotaAvailable = Pipe->InboundQuota;
Fcb->MaxDataLength = Pipe->InboundQuota; Ccb->MaxDataLength = Pipe->InboundQuota;
InitializeListHead(&Fcb->ReadRequestListHead); InitializeListHead(&Ccb->ReadRequestListHead);
ExInitializeFastMutex(&Fcb->DataListLock); ExInitializeFastMutex(&Ccb->DataListLock);
Pipe->CurrentInstances++; Pipe->CurrentInstances++;
Fcb->Pipe = Pipe; Ccb->Pipe = Pipe;
Fcb->PipeEnd = FILE_PIPE_SERVER_END; Ccb->PipeEnd = FILE_PIPE_SERVER_END;
Fcb->PipeState = FILE_PIPE_LISTENING_STATE; Ccb->PipeState = FILE_PIPE_LISTENING_STATE;
Fcb->OtherSide = NULL; Ccb->OtherSide = NULL;
DPRINT("Fcb: %x\n", Fcb); DPRINT("CCB: %x\n", Ccb);
KeInitializeEvent(&Fcb->ConnectEvent, SynchronizationEvent, FALSE); KeInitializeEvent(&Ccb->ConnectEvent, SynchronizationEvent, FALSE);
KeInitializeEvent(&Fcb->ReadEvent, SynchronizationEvent, FALSE); KeInitializeEvent(&Ccb->ReadEvent, SynchronizationEvent, FALSE);
KeInitializeEvent(&Fcb->WriteEvent, SynchronizationEvent, FALSE); KeInitializeEvent(&Ccb->WriteEvent, SynchronizationEvent, FALSE);
KeLockMutex(&Pipe->FcbListLock); KeLockMutex(&Pipe->CcbListLock);
InsertTailList(&Pipe->ServerFcbListHead, &Fcb->FcbListEntry); InsertTailList(&Pipe->ServerCcbListHead, &Ccb->CcbListEntry);
KeUnlockMutex(&Pipe->FcbListLock); KeUnlockMutex(&Pipe->CcbListLock);
FileObject->FsContext = Fcb; FileObject->FsContext2 = Ccb;
FileObject->Flags |= FO_NAMED_PIPE; FileObject->Flags |= FO_NAMED_PIPE;
Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Status = STATUS_SUCCESS;
@ -558,7 +558,7 @@ NpfsCleanup(PDEVICE_OBJECT DeviceObject,
PNPFS_DEVICE_EXTENSION DeviceExt; PNPFS_DEVICE_EXTENSION DeviceExt;
PIO_STACK_LOCATION IoStack; PIO_STACK_LOCATION IoStack;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNPFS_FCB Fcb, OtherSide; PNPFS_CCB Ccb, OtherSide;
PNPFS_PIPE Pipe; PNPFS_PIPE Pipe;
BOOLEAN Server; BOOLEAN Server;
@ -567,9 +567,9 @@ NpfsCleanup(PDEVICE_OBJECT DeviceObject,
IoStack = IoGetCurrentIrpStackLocation(Irp); IoStack = IoGetCurrentIrpStackLocation(Irp);
DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
FileObject = IoStack->FileObject; FileObject = IoStack->FileObject;
Fcb = FileObject->FsContext; Ccb = FileObject->FsContext2;
if (Fcb == NULL) if (Ccb == NULL)
{ {
DPRINT("Success!\n"); DPRINT("Success!\n");
Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Status = STATUS_SUCCESS;
@ -578,14 +578,14 @@ NpfsCleanup(PDEVICE_OBJECT DeviceObject,
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
DPRINT("Fcb %x\n", Fcb); DPRINT("CCB %p\n", Ccb);
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
DPRINT("Cleaning pipe %wZ\n", &Pipe->PipeName); DPRINT("Cleaning pipe %wZ\n", &Pipe->PipeName);
KeLockMutex(&Pipe->FcbListLock); KeLockMutex(&Pipe->CcbListLock);
Server = (Fcb->PipeEnd == FILE_PIPE_SERVER_END); Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END);
if (Server) if (Server)
{ {
@ -596,19 +596,19 @@ NpfsCleanup(PDEVICE_OBJECT DeviceObject,
{ {
DPRINT("Client\n"); DPRINT("Client\n");
} }
if (Fcb->PipeState == FILE_PIPE_CONNECTED_STATE) if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE)
{ {
OtherSide = Fcb->OtherSide; OtherSide = Ccb->OtherSide;
/* Lock the server first */ /* Lock the server first */
if (Server) if (Server)
{ {
ExAcquireFastMutex(&Fcb->DataListLock); ExAcquireFastMutex(&Ccb->DataListLock);
ExAcquireFastMutex(&OtherSide->DataListLock); ExAcquireFastMutex(&OtherSide->DataListLock);
} }
else else
{ {
ExAcquireFastMutex(&OtherSide->DataListLock); ExAcquireFastMutex(&OtherSide->DataListLock);
ExAcquireFastMutex(&Fcb->DataListLock); ExAcquireFastMutex(&Ccb->DataListLock);
} }
OtherSide->PipeState = FILE_PIPE_DISCONNECTED_STATE; OtherSide->PipeState = FILE_PIPE_DISCONNECTED_STATE;
OtherSide->OtherSide = NULL; OtherSide->OtherSide = NULL;
@ -621,15 +621,15 @@ NpfsCleanup(PDEVICE_OBJECT DeviceObject,
if (Server) if (Server)
{ {
ExReleaseFastMutex(&OtherSide->DataListLock); ExReleaseFastMutex(&OtherSide->DataListLock);
ExReleaseFastMutex(&Fcb->DataListLock); ExReleaseFastMutex(&Ccb->DataListLock);
} }
else else
{ {
ExReleaseFastMutex(&Fcb->DataListLock); ExReleaseFastMutex(&Ccb->DataListLock);
ExReleaseFastMutex(&OtherSide->DataListLock); ExReleaseFastMutex(&OtherSide->DataListLock);
} }
} }
else if (Fcb->PipeState == FILE_PIPE_LISTENING_STATE) else if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE)
{ {
PLIST_ENTRY Entry; PLIST_ENTRY Entry;
PNPFS_WAITER_ENTRY WaitEntry = NULL; PNPFS_WAITER_ENTRY WaitEntry = NULL;
@ -637,11 +637,11 @@ NpfsCleanup(PDEVICE_OBJECT DeviceObject,
KIRQL oldIrql; KIRQL oldIrql;
PIRP tmpIrp; PIRP tmpIrp;
Entry = Fcb->Pipe->WaiterListHead.Flink; Entry = Ccb->Pipe->WaiterListHead.Flink;
while (Entry != &Fcb->Pipe->WaiterListHead) while (Entry != &Ccb->Pipe->WaiterListHead)
{ {
WaitEntry = CONTAINING_RECORD(Entry, NPFS_WAITER_ENTRY, Entry); WaitEntry = CONTAINING_RECORD(Entry, NPFS_WAITER_ENTRY, Entry);
if (WaitEntry->Fcb == Fcb) if (WaitEntry->Ccb == Ccb)
{ {
RemoveEntryList(Entry); RemoveEntryList(Entry);
tmpIrp = CONTAINING_RECORD(WaitEntry, IRP, Tail.Overlay.DriverContext); tmpIrp = CONTAINING_RECORD(WaitEntry, IRP, Tail.Overlay.DriverContext);
@ -664,19 +664,19 @@ NpfsCleanup(PDEVICE_OBJECT DeviceObject,
} }
} }
Fcb->PipeState = FILE_PIPE_CLOSING_STATE; Ccb->PipeState = FILE_PIPE_CLOSING_STATE;
KeUnlockMutex(&Pipe->FcbListLock); KeUnlockMutex(&Pipe->CcbListLock);
ExAcquireFastMutex(&Fcb->DataListLock); ExAcquireFastMutex(&Ccb->DataListLock);
if (Fcb->Data) if (Ccb->Data)
{ {
ExFreePool(Fcb->Data); ExFreePool(Ccb->Data);
Fcb->Data = NULL; Ccb->Data = NULL;
Fcb->ReadPtr = NULL; Ccb->ReadPtr = NULL;
Fcb->WritePtr = NULL; Ccb->WritePtr = NULL;
} }
ExReleaseFastMutex(&Fcb->DataListLock); ExReleaseFastMutex(&Ccb->DataListLock);
Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0; Irp->IoStatus.Information = 0;
@ -694,7 +694,7 @@ NpfsClose(PDEVICE_OBJECT DeviceObject,
PNPFS_DEVICE_EXTENSION DeviceExt; PNPFS_DEVICE_EXTENSION DeviceExt;
PIO_STACK_LOCATION IoStack; PIO_STACK_LOCATION IoStack;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNPFS_FCB Fcb; PNPFS_CCB Ccb;
PNPFS_PIPE Pipe; PNPFS_PIPE Pipe;
BOOLEAN Server; BOOLEAN Server;
@ -703,9 +703,9 @@ NpfsClose(PDEVICE_OBJECT DeviceObject,
IoStack = IoGetCurrentIrpStackLocation(Irp); IoStack = IoGetCurrentIrpStackLocation(Irp);
DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
FileObject = IoStack->FileObject; FileObject = IoStack->FileObject;
Fcb = FileObject->FsContext; Ccb = FileObject->FsContext2;
if (Fcb == NULL) if (Ccb == NULL)
{ {
DPRINT("Success!\n"); DPRINT("Success!\n");
Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Status = STATUS_SUCCESS;
@ -714,14 +714,14 @@ NpfsClose(PDEVICE_OBJECT DeviceObject,
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
DPRINT("Fcb %x\n", Fcb); DPRINT("CCB %x\n", Ccb);
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
DPRINT("Closing pipe %wZ\n", &Pipe->PipeName); DPRINT("Closing pipe %wZ\n", &Pipe->PipeName);
KeLockMutex(&Pipe->FcbListLock); KeLockMutex(&Pipe->CcbListLock);
Server = (Fcb->PipeEnd == FILE_PIPE_SERVER_END); Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END);
if (Server) if (Server)
{ {
@ -733,18 +733,18 @@ NpfsClose(PDEVICE_OBJECT DeviceObject,
DPRINT("Client\n"); DPRINT("Client\n");
} }
ASSERT (Fcb->PipeState == FILE_PIPE_CLOSING_STATE); ASSERT(Ccb->PipeState == FILE_PIPE_CLOSING_STATE);
FileObject->FsContext = NULL; FileObject->FsContext2 = NULL;
RemoveEntryList(&Fcb->FcbListEntry); RemoveEntryList(&Ccb->CcbListEntry);
ExFreePool(Fcb); ExFreePool(Ccb);
KeUnlockMutex(&Pipe->FcbListLock); KeUnlockMutex(&Pipe->CcbListLock);
if (IsListEmpty(&Pipe->ServerFcbListHead) && if (IsListEmpty(&Pipe->ServerCcbListHead) &&
IsListEmpty(&Pipe->ClientFcbListHead)) IsListEmpty(&Pipe->ClientCcbListHead))
{ {
RtlFreeUnicodeString(&Pipe->PipeName); RtlFreeUnicodeString(&Pipe->PipeName);
KeLockMutex(&DeviceExt->PipeListLock); KeLockMutex(&DeviceExt->PipeListLock);

58
reactos/drivers/filesystems/np/finfo.c
View file

@ -18,7 +18,7 @@
static static
NTSTATUS NTSTATUS
NpfsSetPipeInformation(PDEVICE_OBJECT DeviceObject, NpfsSetPipeInformation(PDEVICE_OBJECT DeviceObject,
PNPFS_FCB Fcb, PNPFS_CCB Ccb,
PFILE_PIPE_INFORMATION Info, PFILE_PIPE_INFORMATION Info,
PULONG BufferLength) PULONG BufferLength)
{ {
@ -27,7 +27,7 @@ NpfsSetPipeInformation(PDEVICE_OBJECT DeviceObject,
DPRINT("NpfsSetPipeInformation()\n"); DPRINT("NpfsSetPipeInformation()\n");
/* Get the Pipe and data */ /* Get the Pipe and data */
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
Request = (PFILE_PIPE_INFORMATION)Info; Request = (PFILE_PIPE_INFORMATION)Info;
/* Set Pipe Data */ /* Set Pipe Data */
@ -41,7 +41,7 @@ NpfsSetPipeInformation(PDEVICE_OBJECT DeviceObject,
static static
NTSTATUS NTSTATUS
NpfsSetPipeRemoteInformation(PDEVICE_OBJECT DeviceObject, NpfsSetPipeRemoteInformation(PDEVICE_OBJECT DeviceObject,
PNPFS_FCB Fcb, PNPFS_CCB Ccb,
PFILE_PIPE_INFORMATION Info, PFILE_PIPE_INFORMATION Info,
PULONG BufferLength) PULONG BufferLength)
{ {
@ -50,7 +50,7 @@ NpfsSetPipeRemoteInformation(PDEVICE_OBJECT DeviceObject,
DPRINT("NpfsSetPipeRemoteInformation()\n"); DPRINT("NpfsSetPipeRemoteInformation()\n");
/* Get the Pipe and data */ /* Get the Pipe and data */
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
Request = (PFILE_PIPE_REMOTE_INFORMATION)Info; Request = (PFILE_PIPE_REMOTE_INFORMATION)Info;
/* Set the Settings */ /* Set the Settings */
@ -64,7 +64,7 @@ NpfsSetPipeRemoteInformation(PDEVICE_OBJECT DeviceObject,
static static
NTSTATUS NTSTATUS
NpfsQueryPipeInformation(PDEVICE_OBJECT DeviceObject, NpfsQueryPipeInformation(PDEVICE_OBJECT DeviceObject,
PNPFS_FCB Fcb, PNPFS_CCB Ccb,
PFILE_PIPE_INFORMATION Info, PFILE_PIPE_INFORMATION Info,
PULONG BufferLength) PULONG BufferLength)
{ {
@ -72,7 +72,7 @@ NpfsQueryPipeInformation(PDEVICE_OBJECT DeviceObject,
DPRINT("NpfsQueryPipeInformation()\n"); DPRINT("NpfsQueryPipeInformation()\n");
/* Get the Pipe */ /* Get the Pipe */
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
/* Clear Info */ /* Clear Info */
RtlZeroMemory(Info, sizeof(FILE_PIPE_INFORMATION)); RtlZeroMemory(Info, sizeof(FILE_PIPE_INFORMATION));
@ -89,7 +89,7 @@ NpfsQueryPipeInformation(PDEVICE_OBJECT DeviceObject,
static static
NTSTATUS NTSTATUS
NpfsQueryPipeRemoteInformation(PDEVICE_OBJECT DeviceObject, NpfsQueryPipeRemoteInformation(PDEVICE_OBJECT DeviceObject,
PNPFS_FCB Fcb, PNPFS_CCB Ccb,
PFILE_PIPE_REMOTE_INFORMATION Info, PFILE_PIPE_REMOTE_INFORMATION Info,
PULONG BufferLength) PULONG BufferLength)
{ {
@ -97,7 +97,7 @@ NpfsQueryPipeRemoteInformation(PDEVICE_OBJECT DeviceObject,
DPRINT("NpfsQueryPipeRemoteInformation()\n"); DPRINT("NpfsQueryPipeRemoteInformation()\n");
/* Get the Pipe */ /* Get the Pipe */
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
/* Clear Info */ /* Clear Info */
RtlZeroMemory(Info, sizeof(FILE_PIPE_REMOTE_INFORMATION)); RtlZeroMemory(Info, sizeof(FILE_PIPE_REMOTE_INFORMATION));
@ -114,7 +114,7 @@ NpfsQueryPipeRemoteInformation(PDEVICE_OBJECT DeviceObject,
static NTSTATUS static NTSTATUS
NpfsQueryLocalPipeInformation(PDEVICE_OBJECT DeviceObject, NpfsQueryLocalPipeInformation(PDEVICE_OBJECT DeviceObject,
PNPFS_FCB Fcb, PNPFS_CCB Ccb,
PFILE_PIPE_LOCAL_INFORMATION Info, PFILE_PIPE_LOCAL_INFORMATION Info,
PULONG BufferLength) PULONG BufferLength)
{ {
@ -122,7 +122,7 @@ NpfsQueryLocalPipeInformation(PDEVICE_OBJECT DeviceObject,
DPRINT("NpfsQueryLocalPipeInformation()\n"); DPRINT("NpfsQueryLocalPipeInformation()\n");
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
RtlZeroMemory(Info, RtlZeroMemory(Info,
sizeof(FILE_PIPE_LOCAL_INFORMATION)); sizeof(FILE_PIPE_LOCAL_INFORMATION));
@ -133,18 +133,18 @@ NpfsQueryLocalPipeInformation(PDEVICE_OBJECT DeviceObject,
Info->CurrentInstances = Pipe->CurrentInstances; Info->CurrentInstances = Pipe->CurrentInstances;
Info->InboundQuota = Pipe->InboundQuota; Info->InboundQuota = Pipe->InboundQuota;
Info->OutboundQuota = Pipe->OutboundQuota; Info->OutboundQuota = Pipe->OutboundQuota;
Info->NamedPipeState = Fcb->PipeState; Info->NamedPipeState = Ccb->PipeState;
Info->NamedPipeEnd = Fcb->PipeEnd; Info->NamedPipeEnd = Ccb->PipeEnd;
if (Fcb->PipeEnd == FILE_PIPE_SERVER_END) if (Ccb->PipeEnd == FILE_PIPE_SERVER_END)
{ {
Info->ReadDataAvailable = Fcb->ReadDataAvailable; Info->ReadDataAvailable = Ccb->ReadDataAvailable;
Info->WriteQuotaAvailable = Fcb->WriteQuotaAvailable; Info->WriteQuotaAvailable = Ccb->WriteQuotaAvailable;
} }
else if (Fcb->OtherSide != NULL) else if (Ccb->OtherSide != NULL)
{ {
Info->ReadDataAvailable = Fcb->OtherSide->ReadDataAvailable; Info->ReadDataAvailable = Ccb->OtherSide->ReadDataAvailable;
Info->WriteQuotaAvailable = Fcb->OtherSide->WriteQuotaAvailable; Info->WriteQuotaAvailable = Ccb->OtherSide->WriteQuotaAvailable;
} }
*BufferLength -= sizeof(FILE_PIPE_LOCAL_INFORMATION); *BufferLength -= sizeof(FILE_PIPE_LOCAL_INFORMATION);
@ -160,7 +160,7 @@ NpfsQueryInformation(PDEVICE_OBJECT DeviceObject,
FILE_INFORMATION_CLASS FileInformationClass; FILE_INFORMATION_CLASS FileInformationClass;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNPFS_DEVICE_EXTENSION DeviceExtension; PNPFS_DEVICE_EXTENSION DeviceExtension;
PNPFS_FCB Fcb; PNPFS_CCB Ccb;
PNPFS_PIPE Pipe; PNPFS_PIPE Pipe;
PVOID SystemBuffer; PVOID SystemBuffer;
ULONG BufferLength; ULONG BufferLength;
@ -172,8 +172,8 @@ NpfsQueryInformation(PDEVICE_OBJECT DeviceObject,
FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass; FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass;
DeviceExtension = DeviceObject->DeviceExtension; DeviceExtension = DeviceObject->DeviceExtension;
FileObject = IoStack->FileObject; FileObject = IoStack->FileObject;
Fcb = (PNPFS_FCB)FileObject->FsContext; Ccb = (PNPFS_CCB)FileObject->FsContext2;
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
SystemBuffer = Irp->AssociatedIrp.SystemBuffer; SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
BufferLength = IoStack->Parameters.QueryFile.Length; BufferLength = IoStack->Parameters.QueryFile.Length;
@ -187,21 +187,21 @@ NpfsQueryInformation(PDEVICE_OBJECT DeviceObject,
{ {
case FilePipeInformation: case FilePipeInformation:
Status = NpfsQueryPipeInformation(DeviceObject, Status = NpfsQueryPipeInformation(DeviceObject,
Fcb, Ccb,
SystemBuffer, SystemBuffer,
&BufferLength); &BufferLength);
break; break;
case FilePipeLocalInformation: case FilePipeLocalInformation:
Status = NpfsQueryLocalPipeInformation(DeviceObject, Status = NpfsQueryLocalPipeInformation(DeviceObject,
Fcb, Ccb,
SystemBuffer, SystemBuffer,
&BufferLength); &BufferLength);
break; break;
case FilePipeRemoteInformation: case FilePipeRemoteInformation:
Status = NpfsQueryPipeRemoteInformation(DeviceObject, Status = NpfsQueryPipeRemoteInformation(DeviceObject,
Fcb, Ccb,
SystemBuffer, SystemBuffer,
&BufferLength); &BufferLength);
break; break;
@ -229,7 +229,7 @@ NpfsSetInformation(PDEVICE_OBJECT DeviceObject,
PIO_STACK_LOCATION IoStack; PIO_STACK_LOCATION IoStack;
FILE_INFORMATION_CLASS FileInformationClass; FILE_INFORMATION_CLASS FileInformationClass;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNPFS_FCB Fcb; PNPFS_CCB Ccb;
PNPFS_PIPE Pipe; PNPFS_PIPE Pipe;
PVOID SystemBuffer; PVOID SystemBuffer;
ULONG BufferLength; ULONG BufferLength;
@ -240,8 +240,8 @@ NpfsSetInformation(PDEVICE_OBJECT DeviceObject,
IoStack = IoGetCurrentIrpStackLocation (Irp); IoStack = IoGetCurrentIrpStackLocation (Irp);
FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass; FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass;
FileObject = IoStack->FileObject; FileObject = IoStack->FileObject;
Fcb = (PNPFS_FCB)FileObject->FsContext; Ccb = (PNPFS_CCB)FileObject->FsContext2;
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
SystemBuffer = Irp->AssociatedIrp.SystemBuffer; SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
BufferLength = IoStack->Parameters.QueryFile.Length; BufferLength = IoStack->Parameters.QueryFile.Length;
@ -256,7 +256,7 @@ NpfsSetInformation(PDEVICE_OBJECT DeviceObject,
case FilePipeInformation: case FilePipeInformation:
/* Call the handler */ /* Call the handler */
Status = NpfsSetPipeInformation(DeviceObject, Status = NpfsSetPipeInformation(DeviceObject,
Fcb, Ccb,
SystemBuffer, SystemBuffer,
&BufferLength); &BufferLength);
break; break;
@ -268,7 +268,7 @@ NpfsSetInformation(PDEVICE_OBJECT DeviceObject,
case FilePipeRemoteInformation: case FilePipeRemoteInformation:
/* Call the handler */ /* Call the handler */
Status = NpfsSetPipeRemoteInformation(DeviceObject, Status = NpfsSetPipeRemoteInformation(DeviceObject,
Fcb, Ccb,
SystemBuffer, SystemBuffer,
&BufferLength); &BufferLength);
break; break;

186
reactos/drivers/filesystems/np/fsctrl.c
View file

@ -25,14 +25,14 @@ NpfsListeningCancelRoutine(IN PDEVICE_OBJECT DeviceObject,
Waiter = (PNPFS_WAITER_ENTRY)&Irp->Tail.Overlay.DriverContext; Waiter = (PNPFS_WAITER_ENTRY)&Irp->Tail.Overlay.DriverContext;
DPRINT1("NpfsListeningCancelRoutine() called for <%wZ>\n", DPRINT1("NpfsListeningCancelRoutine() called for <%wZ>\n",
&Waiter->Fcb->Pipe->PipeName); &Waiter->Ccb->Pipe->PipeName);
IoReleaseCancelSpinLock(Irp->CancelIrql); IoReleaseCancelSpinLock(Irp->CancelIrql);
KeLockMutex(&Waiter->Fcb->Pipe->FcbListLock); KeLockMutex(&Waiter->Ccb->Pipe->CcbListLock);
RemoveEntryList(&Waiter->Entry); RemoveEntryList(&Waiter->Entry);
KeUnlockMutex(&Waiter->Fcb->Pipe->FcbListLock); KeUnlockMutex(&Waiter->Ccb->Pipe->CcbListLock);
Irp->IoStatus.Status = STATUS_CANCELLED; Irp->IoStatus.Status = STATUS_CANCELLED;
Irp->IoStatus.Information = 0; Irp->IoStatus.Information = 0;
@ -42,26 +42,26 @@ NpfsListeningCancelRoutine(IN PDEVICE_OBJECT DeviceObject,
static NTSTATUS static NTSTATUS
NpfsAddListeningServerInstance(PIRP Irp, NpfsAddListeningServerInstance(PIRP Irp,
PNPFS_FCB Fcb) PNPFS_CCB Ccb)
{ {
PNPFS_WAITER_ENTRY Entry; PNPFS_WAITER_ENTRY Entry;
KIRQL oldIrql; KIRQL oldIrql;
Entry = (PNPFS_WAITER_ENTRY)&Irp->Tail.Overlay.DriverContext; Entry = (PNPFS_WAITER_ENTRY)&Irp->Tail.Overlay.DriverContext;
Entry->Fcb = Fcb; Entry->Ccb = Ccb;
KeLockMutex(&Fcb->Pipe->FcbListLock); KeLockMutex(&Ccb->Pipe->CcbListLock);
IoMarkIrpPending(Irp); IoMarkIrpPending(Irp);
InsertTailList(&Fcb->Pipe->WaiterListHead, &Entry->Entry); InsertTailList(&Ccb->Pipe->WaiterListHead, &Entry->Entry);
IoAcquireCancelSpinLock(&oldIrql); IoAcquireCancelSpinLock(&oldIrql);
if (!Irp->Cancel) if (!Irp->Cancel)
{ {
(void)IoSetCancelRoutine(Irp, NpfsListeningCancelRoutine); (void)IoSetCancelRoutine(Irp, NpfsListeningCancelRoutine);
IoReleaseCancelSpinLock(oldIrql); IoReleaseCancelSpinLock(oldIrql);
KeUnlockMutex(&Fcb->Pipe->FcbListLock); KeUnlockMutex(&Ccb->Pipe->CcbListLock);
return STATUS_PENDING; return STATUS_PENDING;
} }
IoReleaseCancelSpinLock(oldIrql); IoReleaseCancelSpinLock(oldIrql);
@ -71,7 +71,7 @@ NpfsAddListeningServerInstance(PIRP Irp,
Irp->IoStatus.Status = STATUS_CANCELLED; Irp->IoStatus.Status = STATUS_CANCELLED;
Irp->IoStatus.Information = 0; Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
KeUnlockMutex(&Fcb->Pipe->FcbListLock); KeUnlockMutex(&Ccb->Pipe->CcbListLock);
return STATUS_CANCELLED; return STATUS_CANCELLED;
} }
@ -79,67 +79,67 @@ NpfsAddListeningServerInstance(PIRP Irp,
static NTSTATUS static NTSTATUS
NpfsConnectPipe(PIRP Irp, NpfsConnectPipe(PIRP Irp,
PNPFS_FCB Fcb) PNPFS_CCB Ccb)
{ {
PNPFS_PIPE Pipe; PNPFS_PIPE Pipe;
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
PNPFS_FCB ClientFcb; PNPFS_CCB ClientCcb;
NTSTATUS Status; NTSTATUS Status;
DPRINT("NpfsConnectPipe()\n"); DPRINT("NpfsConnectPipe()\n");
if (Fcb->PipeState == FILE_PIPE_CONNECTED_STATE) if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE)
{ {
KeResetEvent(&Fcb->ConnectEvent); KeResetEvent(&Ccb->ConnectEvent);
return STATUS_PIPE_CONNECTED; return STATUS_PIPE_CONNECTED;
} }
if (Fcb->PipeState == FILE_PIPE_CLOSING_STATE) if (Ccb->PipeState == FILE_PIPE_CLOSING_STATE)
return STATUS_PIPE_CLOSING; return STATUS_PIPE_CLOSING;
DPRINT("Waiting for connection...\n"); DPRINT("Waiting for connection...\n");
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
/* search for a listening client fcb */ /* search for a listening client fcb */
KeLockMutex(&Pipe->FcbListLock); KeLockMutex(&Pipe->CcbListLock);
current_entry = Pipe->ClientFcbListHead.Flink; current_entry = Pipe->ClientCcbListHead.Flink;
while (current_entry != &Pipe->ClientFcbListHead) while (current_entry != &Pipe->ClientCcbListHead)
{ {
ClientFcb = CONTAINING_RECORD(current_entry, ClientCcb = CONTAINING_RECORD(current_entry,
NPFS_FCB, NPFS_CCB,
FcbListEntry); CcbListEntry);
if (ClientFcb->PipeState == 0) if (ClientCcb->PipeState == 0)
{ {
/* found a passive (waiting) client fcb */ /* found a passive (waiting) client CCB */
DPRINT("Passive (waiting) client fcb found -- wake the client\n"); DPRINT("Passive (waiting) client CCB found -- wake the client\n");
KeSetEvent(&ClientFcb->ConnectEvent, IO_NO_INCREMENT, FALSE); KeSetEvent(&ClientCcb->ConnectEvent, IO_NO_INCREMENT, FALSE);
break; break;
} }
#if 0 #if 0
if (ClientFcb->PipeState == FILE_PIPE_LISTENING_STATE) if (ClientCcb->PipeState == FILE_PIPE_LISTENING_STATE)
{ {
/* found a listening client fcb */ /* found a listening client CCB */
DPRINT("Listening client fcb found -- connecting\n"); DPRINT("Listening client CCB found -- connecting\n");
/* connect client and server fcb's */ /* connect client and server CCBs */
Fcb->OtherSide = ClientFcb; Ccb->OtherSide = ClientCcb;
ClientFcb->OtherSide = Fcb; ClientCcb->OtherSide = Ccb;
/* set connected state */ /* set connected state */
Fcb->PipeState = FILE_PIPE_CONNECTED_STATE; Ccb->PipeState = FILE_PIPE_CONNECTED_STATE;
ClientFcb->PipeState = FILE_PIPE_CONNECTED_STATE; ClientCcb->PipeState = FILE_PIPE_CONNECTED_STATE;
KeUnlockMutex(&Pipe->FcbListLock); KeUnlockMutex(&Pipe->CcbListLock);
/* FIXME: create and initialize data queues */ /* FIXME: create and initialize data queues */
/* signal client's connect event */ /* signal client's connect event */
DPRINT("Setting the ConnectEvent for %x\n", ClientFcb); DPRINT("Setting the ConnectEvent for %x\n", ClientCcb);
KeSetEvent(&ClientFcb->ConnectEvent, IO_NO_INCREMENT, FALSE); KeSetEvent(&ClientCcb->ConnectEvent, IO_NO_INCREMENT, FALSE);
return STATUS_PIPE_CONNECTED; return STATUS_PIPE_CONNECTED;
} }
@ -151,11 +151,11 @@ NpfsConnectPipe(PIRP Irp,
/* no listening client fcb found */ /* no listening client fcb found */
DPRINT("No listening client fcb found -- waiting for client\n"); DPRINT("No listening client fcb found -- waiting for client\n");
Fcb->PipeState = FILE_PIPE_LISTENING_STATE; Ccb->PipeState = FILE_PIPE_LISTENING_STATE;
Status = NpfsAddListeningServerInstance(Irp, Fcb); Status = NpfsAddListeningServerInstance(Irp, Ccb);
KeUnlockMutex(&Pipe->FcbListLock); KeUnlockMutex(&Pipe->CcbListLock);
DPRINT("NpfsConnectPipe() done (Status %lx)\n", Status); DPRINT("NpfsConnectPipe() done (Status %lx)\n", Status);
@ -164,39 +164,39 @@ NpfsConnectPipe(PIRP Irp,
static NTSTATUS static NTSTATUS
NpfsDisconnectPipe(PNPFS_FCB Fcb) NpfsDisconnectPipe(PNPFS_CCB Ccb)
{ {
NTSTATUS Status; NTSTATUS Status;
PNPFS_FCB OtherSide; PNPFS_CCB OtherSide;
PNPFS_PIPE Pipe; PNPFS_PIPE Pipe;
BOOLEAN Server; BOOLEAN Server;
DPRINT("NpfsDisconnectPipe()\n"); DPRINT("NpfsDisconnectPipe()\n");
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
KeLockMutex(&Pipe->FcbListLock); KeLockMutex(&Pipe->CcbListLock);
if (Fcb->PipeState == FILE_PIPE_DISCONNECTED_STATE) if (Ccb->PipeState == FILE_PIPE_DISCONNECTED_STATE)
{ {
DPRINT("Pipe is already disconnected\n"); DPRINT("Pipe is already disconnected\n");
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
} }
else if (Fcb->PipeState == FILE_PIPE_CONNECTED_STATE) else if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE)
{ {
Server = (Fcb->PipeEnd == FILE_PIPE_SERVER_END); Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END);
OtherSide = Fcb->OtherSide; OtherSide = Ccb->OtherSide;
Fcb->OtherSide = NULL; Ccb->OtherSide = NULL;
Fcb->PipeState = FILE_PIPE_DISCONNECTED_STATE; Ccb->PipeState = FILE_PIPE_DISCONNECTED_STATE;
/* Lock the server first */ /* Lock the server first */
if (Server) if (Server)
{ {
ExAcquireFastMutex(&Fcb->DataListLock); ExAcquireFastMutex(&Ccb->DataListLock);
ExAcquireFastMutex(&OtherSide->DataListLock); ExAcquireFastMutex(&OtherSide->DataListLock);
} }
else else
{ {
ExAcquireFastMutex(&OtherSide->DataListLock); ExAcquireFastMutex(&OtherSide->DataListLock);
ExAcquireFastMutex(&Fcb->DataListLock); ExAcquireFastMutex(&Ccb->DataListLock);
} }
OtherSide->PipeState = FILE_PIPE_DISCONNECTED_STATE; OtherSide->PipeState = FILE_PIPE_DISCONNECTED_STATE;
OtherSide->OtherSide = NULL; OtherSide->OtherSide = NULL;
@ -209,27 +209,27 @@ NpfsDisconnectPipe(PNPFS_FCB Fcb)
if (Server) if (Server)
{ {
ExReleaseFastMutex(&OtherSide->DataListLock); ExReleaseFastMutex(&OtherSide->DataListLock);
ExReleaseFastMutex(&Fcb->DataListLock); ExReleaseFastMutex(&Ccb->DataListLock);
} }
else else
{ {
ExReleaseFastMutex(&Fcb->DataListLock); ExReleaseFastMutex(&Ccb->DataListLock);
ExReleaseFastMutex(&OtherSide->DataListLock); ExReleaseFastMutex(&OtherSide->DataListLock);
} }
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
} }
else if (Fcb->PipeState == FILE_PIPE_LISTENING_STATE) else if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE)
{ {
PLIST_ENTRY Entry; PLIST_ENTRY Entry;
PNPFS_WAITER_ENTRY WaitEntry = NULL; PNPFS_WAITER_ENTRY WaitEntry = NULL;
BOOLEAN Complete = FALSE; BOOLEAN Complete = FALSE;
PIRP Irp = NULL; PIRP Irp = NULL;
Entry = Fcb->Pipe->WaiterListHead.Flink; Entry = Ccb->Pipe->WaiterListHead.Flink;
while (Entry != &Fcb->Pipe->WaiterListHead) while (Entry != &Ccb->Pipe->WaiterListHead)
{ {
WaitEntry = CONTAINING_RECORD(Entry, NPFS_WAITER_ENTRY, Entry); WaitEntry = CONTAINING_RECORD(Entry, NPFS_WAITER_ENTRY, Entry);
if (WaitEntry->Fcb == Fcb) if (WaitEntry->Ccb == Ccb)
{ {
RemoveEntryList(Entry); RemoveEntryList(Entry);
Irp = CONTAINING_RECORD(Entry, IRP, Tail.Overlay.DriverContext); Irp = CONTAINING_RECORD(Entry, IRP, Tail.Overlay.DriverContext);
@ -248,10 +248,10 @@ NpfsDisconnectPipe(PNPFS_FCB Fcb)
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
} }
} }
Fcb->PipeState = FILE_PIPE_DISCONNECTED_STATE; Ccb->PipeState = FILE_PIPE_DISCONNECTED_STATE;
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
} }
else if (Fcb->PipeState == FILE_PIPE_CLOSING_STATE) else if (Ccb->PipeState == FILE_PIPE_CLOSING_STATE)
{ {
Status = STATUS_PIPE_CLOSING; Status = STATUS_PIPE_CLOSING;
} }
@ -259,44 +259,44 @@ NpfsDisconnectPipe(PNPFS_FCB Fcb)
{ {
Status = STATUS_UNSUCCESSFUL; Status = STATUS_UNSUCCESSFUL;
} }
KeUnlockMutex(&Pipe->FcbListLock); KeUnlockMutex(&Pipe->CcbListLock);
return Status; return Status;
} }
static NTSTATUS static NTSTATUS
NpfsWaitPipe(PIRP Irp, NpfsWaitPipe(PIRP Irp,
PNPFS_FCB Fcb) PNPFS_CCB Ccb)
{ {
PNPFS_PIPE Pipe; PNPFS_PIPE Pipe;
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
PNPFS_FCB ServerFcb; PNPFS_CCB ServerCcb;
PFILE_PIPE_WAIT_FOR_BUFFER WaitPipe; PFILE_PIPE_WAIT_FOR_BUFFER WaitPipe;
NTSTATUS Status; NTSTATUS Status;
DPRINT("NpfsWaitPipe\n"); DPRINT("NpfsWaitPipe\n");
WaitPipe = (PFILE_PIPE_WAIT_FOR_BUFFER)Irp->AssociatedIrp.SystemBuffer; WaitPipe = (PFILE_PIPE_WAIT_FOR_BUFFER)Irp->AssociatedIrp.SystemBuffer;
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
if (Fcb->PipeState != 0) if (Ccb->PipeState != 0)
{ {
DPRINT("Pipe is not in passive (waiting) state!\n"); DPRINT("Pipe is not in passive (waiting) state!\n");
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
/* search for listening server */ /* search for listening server */
current_entry = Pipe->ServerFcbListHead.Flink; current_entry = Pipe->ServerCcbListHead.Flink;
while (current_entry != &Pipe->ServerFcbListHead) while (current_entry != &Pipe->ServerCcbListHead)
{ {
ServerFcb = CONTAINING_RECORD(current_entry, ServerCcb = CONTAINING_RECORD(current_entry,
NPFS_FCB, NPFS_CCB,
FcbListEntry); CcbListEntry);
if (ServerFcb->PipeState == FILE_PIPE_LISTENING_STATE) if (ServerCcb->PipeState == FILE_PIPE_LISTENING_STATE)
{ {
/* found a listening server fcb */ /* found a listening server CCB */
DPRINT("Listening server fcb found -- connecting\n"); DPRINT("Listening server CCB found -- connecting\n");
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
@ -305,7 +305,7 @@ NpfsWaitPipe(PIRP Irp,
} }
/* no listening server fcb found -- wait for one */ /* no listening server fcb found -- wait for one */
Status = KeWaitForSingleObject(&Fcb->ConnectEvent, Status = KeWaitForSingleObject(&Ccb->ConnectEvent,
UserRequest, UserRequest,
KernelMode, KernelMode,
FALSE, FALSE,
@ -341,26 +341,42 @@ NpfsPeekPipe(PIRP Irp,
ULONG OutputBufferLength; ULONG OutputBufferLength;
PNPFS_PIPE Pipe; PNPFS_PIPE Pipe;
PFILE_PIPE_PEEK_BUFFER Reply; PFILE_PIPE_PEEK_BUFFER Reply;
PNPFS_FCB Fcb; PNPFS_CCB Ccb;
NTSTATUS Status; NTSTATUS Status;
DPRINT("NpfsPeekPipe\n"); DPRINT1("NpfsPeekPipe\n");
OutputBufferLength = IoStack->Parameters.DeviceIoControl.OutputBufferLength; OutputBufferLength = IoStack->Parameters.DeviceIoControl.OutputBufferLength;
DPRINT1("OutputBufferLength: %lu\n", OutputBufferLength);
/* Validate parameters */ /* Validate parameters */
if (OutputBufferLength < sizeof(FILE_PIPE_PEEK_BUFFER)) if (OutputBufferLength < sizeof(FILE_PIPE_PEEK_BUFFER))
{ {
DPRINT("Buffer too small\n"); DPRINT1("Buffer too small\n");
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
Fcb = IoStack->FileObject->FsContext; Ccb = IoStack->FileObject->FsContext2;
Reply = (PFILE_PIPE_PEEK_BUFFER)Irp->AssociatedIrp.SystemBuffer; Reply = (PFILE_PIPE_PEEK_BUFFER)Irp->AssociatedIrp.SystemBuffer;
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
Reply->NamedPipeState = Ccb->PipeState;
Reply->ReadDataAvailable = Ccb->ReadDataAvailable;
DPRINT("ReadDataAvailable: %lu\n", Ccb->ReadDataAvailable);
Reply->NumberOfMessages = 0; /* FIXME */
Reply->MessageLength = 0; /* FIXME */
Reply->Data[0] = 0; /* FIXME */
// Irp->IoStatus.Information = sizeof(FILE_PIPE_PEEK_BUFFER);
// Status = STATUS_SUCCESS;
Status = STATUS_NOT_IMPLEMENTED; Status = STATUS_NOT_IMPLEMENTED;
DPRINT1("NpfsPeekPipe done\n");
return Status; return Status;
} }
@ -374,7 +390,7 @@ NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
NTSTATUS Status; NTSTATUS Status;
PNPFS_DEVICE_EXTENSION DeviceExt; PNPFS_DEVICE_EXTENSION DeviceExt;
PNPFS_PIPE Pipe; PNPFS_PIPE Pipe;
PNPFS_FCB Fcb; PNPFS_CCB Ccb;
DPRINT("NpfsFileSystemContol(DeviceObject %p Irp %p)\n", DeviceObject, Irp); DPRINT("NpfsFileSystemContol(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
@ -383,9 +399,9 @@ NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
DPRINT("IoStack: %p\n", IoStack); DPRINT("IoStack: %p\n", IoStack);
FileObject = IoStack->FileObject; FileObject = IoStack->FileObject;
DPRINT("FileObject: %p\n", FileObject); DPRINT("FileObject: %p\n", FileObject);
Fcb = FileObject->FsContext; Ccb = FileObject->FsContext2;
DPRINT("Fcb: %p\n", Fcb); DPRINT("CCB: %p\n", Ccb);
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
DPRINT("Pipe: %p\n", Pipe); DPRINT("Pipe: %p\n", Pipe);
DPRINT("PipeName: %wZ\n", &Pipe->PipeName); DPRINT("PipeName: %wZ\n", &Pipe->PipeName);
@ -400,12 +416,12 @@ NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
case FSCTL_PIPE_DISCONNECT: case FSCTL_PIPE_DISCONNECT:
DPRINT("Disconnecting pipe %wZ\n", &Pipe->PipeName); DPRINT("Disconnecting pipe %wZ\n", &Pipe->PipeName);
Status = NpfsDisconnectPipe(Fcb); Status = NpfsDisconnectPipe(Ccb);
break; break;
case FSCTL_PIPE_LISTEN: case FSCTL_PIPE_LISTEN:
DPRINT("Connecting pipe %wZ\n", &Pipe->PipeName); DPRINT("Connecting pipe %wZ\n", &Pipe->PipeName);
Status = NpfsConnectPipe(Irp, Fcb); Status = NpfsConnectPipe(Irp, Ccb);
break; break;
case FSCTL_PIPE_PEEK: case FSCTL_PIPE_PEEK:
@ -427,7 +443,7 @@ NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
case FSCTL_PIPE_WAIT: case FSCTL_PIPE_WAIT:
DPRINT("Waiting for pipe %wZ\n", &Pipe->PipeName); DPRINT("Waiting for pipe %wZ\n", &Pipe->PipeName);
Status = NpfsWaitPipe(Irp, Fcb); Status = NpfsWaitPipe(Irp, Ccb);
break; break;
case FSCTL_PIPE_IMPERSONATE: case FSCTL_PIPE_IMPERSONATE:

16
reactos/drivers/filesystems/np/npfs.h
View file

@ -19,9 +19,9 @@ typedef struct _NPFS_PIPE
{ {
UNICODE_STRING PipeName; UNICODE_STRING PipeName;
LIST_ENTRY PipeListEntry; LIST_ENTRY PipeListEntry;
KMUTEX FcbListLock; KMUTEX CcbListLock;
LIST_ENTRY ServerFcbListHead; LIST_ENTRY ServerCcbListHead;
LIST_ENTRY ClientFcbListHead; LIST_ENTRY ClientCcbListHead;
LIST_ENTRY WaiterListHead; LIST_ENTRY WaiterListHead;
LIST_ENTRY EmptyBufferListHead; LIST_ENTRY EmptyBufferListHead;
ULONG PipeType; ULONG PipeType;
@ -36,10 +36,10 @@ typedef struct _NPFS_PIPE
LARGE_INTEGER TimeOut; LARGE_INTEGER TimeOut;
} NPFS_PIPE, *PNPFS_PIPE; } NPFS_PIPE, *PNPFS_PIPE;
typedef struct _NPFS_FCB typedef struct _NPFS_CCB
{ {
LIST_ENTRY FcbListEntry; LIST_ENTRY CcbListEntry;
struct _NPFS_FCB* OtherSide; struct _NPFS_CCB* OtherSide;
struct ETHREAD *Thread; struct ETHREAD *Thread;
PNPFS_PIPE Pipe; PNPFS_PIPE Pipe;
KEVENT ConnectEvent; KEVENT ConnectEvent;
@ -58,7 +58,7 @@ typedef struct _NPFS_FCB
ULONG MaxDataLength; ULONG MaxDataLength;
FAST_MUTEX DataListLock; /* Data queue lock */ FAST_MUTEX DataListLock; /* Data queue lock */
} NPFS_FCB, *PNPFS_FCB; } NPFS_CCB, *PNPFS_CCB;
typedef struct _NPFS_CONTEXT typedef struct _NPFS_CONTEXT
{ {
@ -80,7 +80,7 @@ typedef struct _NPFS_THREAD_CONTEXT
typedef struct _NPFS_WAITER_ENTRY typedef struct _NPFS_WAITER_ENTRY
{ {
LIST_ENTRY Entry; LIST_ENTRY Entry;
PNPFS_FCB Fcb; PNPFS_CCB Ccb;
} NPFS_WAITER_ENTRY, *PNPFS_WAITER_ENTRY; } NPFS_WAITER_ENTRY, *PNPFS_WAITER_ENTRY;

248
reactos/drivers/filesystems/np/rw.c
View file

@ -50,7 +50,7 @@ NpfsReadWriteCancelRoutine(IN PDEVICE_OBJECT DeviceObject,
PNPFS_CONTEXT Context; PNPFS_CONTEXT Context;
PNPFS_DEVICE_EXTENSION DeviceExt; PNPFS_DEVICE_EXTENSION DeviceExt;
PIO_STACK_LOCATION IoStack; PIO_STACK_LOCATION IoStack;
PNPFS_FCB Fcb; PNPFS_CCB Ccb;
BOOLEAN Complete = FALSE; BOOLEAN Complete = FALSE;
DPRINT("NpfsReadWriteCancelRoutine(DeviceObject %x, Irp %x)\n", DeviceObject, Irp); DPRINT("NpfsReadWriteCancelRoutine(DeviceObject %x, Irp %x)\n", DeviceObject, Irp);
@ -60,14 +60,14 @@ NpfsReadWriteCancelRoutine(IN PDEVICE_OBJECT DeviceObject,
Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext; Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext;
DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
IoStack = IoGetCurrentIrpStackLocation(Irp); IoStack = IoGetCurrentIrpStackLocation(Irp);
Fcb = IoStack->FileObject->FsContext; Ccb = IoStack->FileObject->FsContext2;
KeLockMutex(&DeviceExt->PipeListLock); KeLockMutex(&DeviceExt->PipeListLock);
ExAcquireFastMutex(&Fcb->DataListLock); ExAcquireFastMutex(&Ccb->DataListLock);
switch(IoStack->MajorFunction) switch(IoStack->MajorFunction)
{ {
case IRP_MJ_READ: case IRP_MJ_READ:
if (Fcb->ReadRequestListHead.Flink != &Context->ListEntry) if (Ccb->ReadRequestListHead.Flink != &Context->ListEntry)
{ {
/* we are not the first in the list, remove an complete us */ /* we are not the first in the list, remove an complete us */
RemoveEntryList(&Context->ListEntry); RemoveEntryList(&Context->ListEntry);
@ -75,13 +75,13 @@ NpfsReadWriteCancelRoutine(IN PDEVICE_OBJECT DeviceObject,
} }
else else
{ {
KeSetEvent(&Fcb->ReadEvent, IO_NO_INCREMENT, FALSE); KeSetEvent(&Ccb->ReadEvent, IO_NO_INCREMENT, FALSE);
} }
break; break;
default: default:
KEBUGCHECK(0); KEBUGCHECK(0);
} }
ExReleaseFastMutex(&Fcb->DataListLock); ExReleaseFastMutex(&Ccb->DataListLock);
KeUnlockMutex(&DeviceExt->PipeListLock); KeUnlockMutex(&DeviceExt->PipeListLock);
if (Complete) if (Complete)
{ {
@ -105,7 +105,7 @@ NpfsWaiterThread(PVOID InitContext)
PIO_STACK_LOCATION IoStack = NULL; PIO_STACK_LOCATION IoStack = NULL;
PNPFS_CONTEXT Context; PNPFS_CONTEXT Context;
PNPFS_CONTEXT NextContext; PNPFS_CONTEXT NextContext;
PNPFS_FCB Fcb; PNPFS_CCB Ccb;
KeLockMutex(&ThreadContext->DeviceExt->PipeListLock); KeLockMutex(&ThreadContext->DeviceExt->PipeListLock);
@ -166,16 +166,16 @@ NpfsWaiterThread(PVOID InitContext)
if (Cancel) if (Cancel)
{ {
Fcb = IoStack->FileObject->FsContext; Ccb = IoStack->FileObject->FsContext2;
ExAcquireFastMutex(&Fcb->DataListLock); ExAcquireFastMutex(&Ccb->DataListLock);
RemoveEntryList(&Context->ListEntry); RemoveEntryList(&Context->ListEntry);
switch (IoStack->MajorFunction) switch (IoStack->MajorFunction)
{ {
case IRP_MJ_READ: case IRP_MJ_READ:
if (!IsListEmpty(&Fcb->ReadRequestListHead)) if (!IsListEmpty(&Ccb->ReadRequestListHead))
{ {
/* put the next request on the wait list */ /* put the next request on the wait list */
NextContext = CONTAINING_RECORD(Fcb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry); NextContext = CONTAINING_RECORD(Ccb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry);
ThreadContext->WaitObjectArray[ThreadContext->Count] = NextContext->WaitEvent; ThreadContext->WaitObjectArray[ThreadContext->Count] = NextContext->WaitEvent;
NextIrp = CONTAINING_RECORD(NextContext, IRP, Tail.Overlay.DriverContext); NextIrp = CONTAINING_RECORD(NextContext, IRP, Tail.Overlay.DriverContext);
ThreadContext->WaitIrpArray[ThreadContext->Count] = NextIrp; ThreadContext->WaitIrpArray[ThreadContext->Count] = NextIrp;
@ -186,7 +186,7 @@ NpfsWaiterThread(PVOID InitContext)
default: default:
KEBUGCHECK(0); KEBUGCHECK(0);
} }
ExReleaseFastMutex(&Fcb->DataListLock); ExReleaseFastMutex(&Ccb->DataListLock);
} }
} }
else else
@ -294,11 +294,11 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
NTSTATUS Status; NTSTATUS Status;
NTSTATUS OriginalStatus = STATUS_SUCCESS; NTSTATUS OriginalStatus = STATUS_SUCCESS;
PNPFS_FCB Fcb; PNPFS_CCB Ccb;
PNPFS_CONTEXT Context; PNPFS_CONTEXT Context;
KEVENT Event; KEVENT Event;
ULONG Length; ULONG Length;
ULONG Information; ULONG Information = 0;
ULONG CopyLength; ULONG CopyLength;
ULONG TempLength; ULONG TempLength;
BOOLEAN IsOriginalRequest = TRUE; BOOLEAN IsOriginalRequest = TRUE;
@ -315,15 +315,15 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
} }
FileObject = IoGetCurrentIrpStackLocation(Irp)->FileObject; FileObject = IoGetCurrentIrpStackLocation(Irp)->FileObject;
Fcb = FileObject->FsContext; Ccb = FileObject->FsContext2;
Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext; Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext;
if (Fcb->OtherSide == NULL) if (Ccb->OtherSide == NULL)
{ {
DPRINT("Pipe is NOT connected!\n"); DPRINT("Pipe is NOT connected!\n");
if (Fcb->PipeState == FILE_PIPE_LISTENING_STATE) if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE)
Status = STATUS_PIPE_LISTENING; Status = STATUS_PIPE_LISTENING;
else if (Fcb->PipeState == FILE_PIPE_DISCONNECTED_STATE) else if (Ccb->PipeState == FILE_PIPE_DISCONNECTED_STATE)
Status = STATUS_PIPE_DISCONNECTED; Status = STATUS_PIPE_DISCONNECTED;
else else
Status = STATUS_UNSUCCESSFUL; Status = STATUS_UNSUCCESSFUL;
@ -331,7 +331,7 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
goto done; goto done;
} }
if (Fcb->Data == NULL) if (Ccb->Data == NULL)
{ {
DPRINT1("Pipe is NOT readable!\n"); DPRINT1("Pipe is NOT readable!\n");
Status = STATUS_UNSUCCESSFUL; Status = STATUS_UNSUCCESSFUL;
@ -339,16 +339,16 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
goto done; goto done;
} }
ExAcquireFastMutex(&Fcb->DataListLock); ExAcquireFastMutex(&Ccb->DataListLock);
if (IoIsOperationSynchronous(Irp)) if (IoIsOperationSynchronous(Irp))
{ {
InsertTailList(&Fcb->ReadRequestListHead, &Context->ListEntry); InsertTailList(&Ccb->ReadRequestListHead, &Context->ListEntry);
if (Fcb->ReadRequestListHead.Flink != &Context->ListEntry) if (Ccb->ReadRequestListHead.Flink != &Context->ListEntry)
{ {
KeInitializeEvent(&Event, SynchronizationEvent, FALSE); KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
Context->WaitEvent = &Event; Context->WaitEvent = &Event;
ExReleaseFastMutex(&Fcb->DataListLock); ExReleaseFastMutex(&Ccb->DataListLock);
Status = KeWaitForSingleObject(&Event, Status = KeWaitForSingleObject(&Event,
Executive, Executive,
KernelMode, KernelMode,
@ -358,21 +358,21 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
{ {
KEBUGCHECK(0); KEBUGCHECK(0);
} }
ExAcquireFastMutex(&Fcb->DataListLock); ExAcquireFastMutex(&Ccb->DataListLock);
} }
Irp->IoStatus.Information = 0; Irp->IoStatus.Information = 0;
} }
else else
{ {
KIRQL oldIrql; KIRQL oldIrql;
if (IsListEmpty(&Fcb->ReadRequestListHead) || if (IsListEmpty(&Ccb->ReadRequestListHead) ||
Fcb->ReadRequestListHead.Flink != &Context->ListEntry) Ccb->ReadRequestListHead.Flink != &Context->ListEntry)
{ {
/* this is a new request */ /* this is a new request */
Irp->IoStatus.Information = 0; Irp->IoStatus.Information = 0;
Context->WaitEvent = &Fcb->ReadEvent; Context->WaitEvent = &Ccb->ReadEvent;
InsertTailList(&Fcb->ReadRequestListHead, &Context->ListEntry); InsertTailList(&Ccb->ReadRequestListHead, &Context->ListEntry);
if (Fcb->ReadRequestListHead.Flink != &Context->ListEntry) if (Ccb->ReadRequestListHead.Flink != &Context->ListEntry)
{ {
/* there was already a request on the list */ /* there was already a request on the list */
IoAcquireCancelSpinLock(&oldIrql); IoAcquireCancelSpinLock(&oldIrql);
@ -380,13 +380,13 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
{ {
IoReleaseCancelSpinLock(oldIrql); IoReleaseCancelSpinLock(oldIrql);
RemoveEntryList(&Context->ListEntry); RemoveEntryList(&Context->ListEntry);
ExReleaseFastMutex(&Fcb->DataListLock); ExReleaseFastMutex(&Ccb->DataListLock);
Status = STATUS_CANCELLED; Status = STATUS_CANCELLED;
goto done; goto done;
} }
(void)IoSetCancelRoutine(Irp, NpfsReadWriteCancelRoutine); (void)IoSetCancelRoutine(Irp, NpfsReadWriteCancelRoutine);
IoReleaseCancelSpinLock(oldIrql); IoReleaseCancelSpinLock(oldIrql);
ExReleaseFastMutex(&Fcb->DataListLock); ExReleaseFastMutex(&Ccb->DataListLock);
IoMarkIrpPending(Irp); IoMarkIrpPending(Irp);
Status = STATUS_PENDING; Status = STATUS_PENDING;
goto done; goto done;
@ -406,94 +406,94 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
while (1) while (1)
{ {
if (Fcb->ReadDataAvailable == 0) if (Ccb->ReadDataAvailable == 0)
{ {
if (Fcb->PipeState == FILE_PIPE_CONNECTED_STATE) if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE)
{ {
ASSERT(Fcb->OtherSide != NULL); ASSERT(Ccb->OtherSide != NULL);
KeSetEvent(&Fcb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE); KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE);
} }
if (Information > 0 && if (Information > 0 &&
(Fcb->Pipe->ReadMode != FILE_PIPE_BYTE_STREAM_MODE || (Ccb->Pipe->ReadMode != FILE_PIPE_BYTE_STREAM_MODE ||
Fcb->PipeState != FILE_PIPE_CONNECTED_STATE)) Ccb->PipeState != FILE_PIPE_CONNECTED_STATE))
{ {
break; break;
} }
if (Fcb->PipeState != FILE_PIPE_CONNECTED_STATE) if (Ccb->PipeState != FILE_PIPE_CONNECTED_STATE)
{ {
DPRINT("PipeState: %x\n", Fcb->PipeState); DPRINT("PipeState: %x\n", Ccb->PipeState);
Status = STATUS_PIPE_BROKEN; Status = STATUS_PIPE_BROKEN;
break; break;
} }
ExReleaseFastMutex(&Fcb->DataListLock); ExReleaseFastMutex(&Ccb->DataListLock);
if (IoIsOperationSynchronous(Irp)) if (IoIsOperationSynchronous(Irp))
{ {
/* Wait for ReadEvent to become signaled */ /* Wait for ReadEvent to become signaled */
DPRINT("Waiting for readable data (%wZ)\n", &Fcb->Pipe->PipeName); DPRINT1("Waiting for readable data (%wZ)\n", &Ccb->Pipe->PipeName);
Status = KeWaitForSingleObject(&Fcb->ReadEvent, Status = KeWaitForSingleObject(&Ccb->ReadEvent,
UserRequest, UserRequest,
KernelMode, KernelMode,
FALSE, FALSE,
NULL); NULL);
DPRINT("Finished waiting (%wZ)! Status: %x\n", &Fcb->Pipe->PipeName, Status); DPRINT("Finished waiting (%wZ)! Status: %x\n", &Ccb->Pipe->PipeName, Status);
ExAcquireFastMutex(&Fcb->DataListLock); ExAcquireFastMutex(&Ccb->DataListLock);
} }
else else
{ {
Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext; Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext;
Context->WaitEvent = &Fcb->ReadEvent; Context->WaitEvent = &Ccb->ReadEvent;
Status = NpfsAddWaitingReadWriteRequest(DeviceObject, Irp); Status = NpfsAddWaitingReadWriteRequest(DeviceObject, Irp);
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
Status = STATUS_PENDING; Status = STATUS_PENDING;
} }
ExAcquireFastMutex(&Fcb->DataListLock); ExAcquireFastMutex(&Ccb->DataListLock);
break; break;
} }
} }
ASSERT(IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL); ASSERT(IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL);
if (Fcb->Pipe->ReadMode == FILE_PIPE_BYTE_STREAM_MODE) if (Ccb->Pipe->ReadMode == FILE_PIPE_BYTE_STREAM_MODE)
{ {
DPRINT("Byte stream mode\n"); DPRINT("Byte stream mode\n");
/* Byte stream mode */ /* Byte stream mode */
while (Length > 0 && Fcb->ReadDataAvailable > 0) while (Length > 0 && Ccb->ReadDataAvailable > 0)
{ {
CopyLength = min(Fcb->ReadDataAvailable, Length); CopyLength = min(Ccb->ReadDataAvailable, Length);
if ((ULONG_PTR)Fcb->ReadPtr + CopyLength <= (ULONG_PTR)Fcb->Data + Fcb->MaxDataLength) if ((ULONG_PTR)Ccb->ReadPtr + CopyLength <= (ULONG_PTR)Ccb->Data + Ccb->MaxDataLength)
{ {
memcpy(Buffer, Fcb->ReadPtr, CopyLength); memcpy(Buffer, Ccb->ReadPtr, CopyLength);
Fcb->ReadPtr = (PVOID)((ULONG_PTR)Fcb->ReadPtr + CopyLength); Ccb->ReadPtr = (PVOID)((ULONG_PTR)Ccb->ReadPtr + CopyLength);
if (Fcb->ReadPtr == (PVOID)((ULONG_PTR)Fcb->Data + Fcb->MaxDataLength)) if (Ccb->ReadPtr == (PVOID)((ULONG_PTR)Ccb->Data + Ccb->MaxDataLength))
{ {
Fcb->ReadPtr = Fcb->Data; Ccb->ReadPtr = Ccb->Data;
} }
} }
else else
{ {
TempLength = (ULONG)((ULONG_PTR)Fcb->Data + Fcb->MaxDataLength - (ULONG_PTR)Fcb->ReadPtr); TempLength = (ULONG)((ULONG_PTR)Ccb->Data + Ccb->MaxDataLength - (ULONG_PTR)Ccb->ReadPtr);
memcpy(Buffer, Fcb->ReadPtr, TempLength); memcpy(Buffer, Ccb->ReadPtr, TempLength);
memcpy((PVOID)((ULONG_PTR)Buffer + TempLength), Fcb->Data, CopyLength - TempLength); memcpy((PVOID)((ULONG_PTR)Buffer + TempLength), Ccb->Data, CopyLength - TempLength);
Fcb->ReadPtr = (PVOID)((ULONG_PTR)Fcb->Data + CopyLength - TempLength); Ccb->ReadPtr = (PVOID)((ULONG_PTR)Ccb->Data + CopyLength - TempLength);
} }
Buffer = (PVOID)((ULONG_PTR)Buffer + CopyLength); Buffer = (PVOID)((ULONG_PTR)Buffer + CopyLength);
Length -= CopyLength; Length -= CopyLength;
Information += CopyLength; Information += CopyLength;
Fcb->ReadDataAvailable -= CopyLength; Ccb->ReadDataAvailable -= CopyLength;
Fcb->WriteQuotaAvailable += CopyLength; Ccb->WriteQuotaAvailable += CopyLength;
} }
if (Length == 0) if (Length == 0)
{ {
if (Fcb->PipeState == FILE_PIPE_CONNECTED_STATE) if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE)
{ {
KeSetEvent(&Fcb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE); KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE);
} }
KeResetEvent(&Fcb->ReadEvent); KeResetEvent(&Ccb->ReadEvent);
break; break;
} }
} }
@ -502,11 +502,11 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
DPRINT("Message mode\n"); DPRINT("Message mode\n");
/* Message mode */ /* Message mode */
if (Fcb->ReadDataAvailable) if (Ccb->ReadDataAvailable)
{ {
/* Truncate the message if the receive buffer is too small */ /* Truncate the message if the receive buffer is too small */
CopyLength = min(Fcb->ReadDataAvailable, Length); CopyLength = min(Ccb->ReadDataAvailable, Length);
memcpy(Buffer, Fcb->Data, CopyLength); memcpy(Buffer, Ccb->Data, CopyLength);
#ifndef NDEBUG #ifndef NDEBUG
DPRINT("Length %d Buffer %x\n",CopyLength,Buffer); DPRINT("Length %d Buffer %x\n",CopyLength,Buffer);
@ -515,22 +515,22 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
Information = CopyLength; Information = CopyLength;
if (Fcb->ReadDataAvailable > Length) if (Ccb->ReadDataAvailable > Length)
{ {
memmove(Fcb->Data, (PVOID)((ULONG_PTR)Fcb->Data + Length), memmove(Ccb->Data, (PVOID)((ULONG_PTR)Ccb->Data + Length),
Fcb->ReadDataAvailable - Length); Ccb->ReadDataAvailable - Length);
Fcb->ReadDataAvailable -= Length; Ccb->ReadDataAvailable -= Length;
Status = STATUS_MORE_ENTRIES; Status = STATUS_MORE_ENTRIES;
} }
else else
{ {
KeResetEvent(&Fcb->ReadEvent); KeResetEvent(&Ccb->ReadEvent);
if (Fcb->PipeState == FILE_PIPE_CONNECTED_STATE) if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE)
{ {
KeSetEvent(&Fcb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE); KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE);
} }
Fcb->ReadDataAvailable = 0; Ccb->ReadDataAvailable = 0;
Fcb->WriteQuotaAvailable = Fcb->MaxDataLength; Ccb->WriteQuotaAvailable = Ccb->MaxDataLength;
} }
} }
@ -548,12 +548,12 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
if (IoIsOperationSynchronous(Irp)) if (IoIsOperationSynchronous(Irp))
{ {
RemoveEntryList(&Context->ListEntry); RemoveEntryList(&Context->ListEntry);
if (!IsListEmpty(&Fcb->ReadRequestListHead)) if (!IsListEmpty(&Ccb->ReadRequestListHead))
{ {
Context = CONTAINING_RECORD(Fcb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry); Context = CONTAINING_RECORD(Ccb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry);
KeSetEvent(Context->WaitEvent, IO_NO_INCREMENT, FALSE); KeSetEvent(Context->WaitEvent, IO_NO_INCREMENT, FALSE);
} }
ExReleaseFastMutex(&Fcb->DataListLock); ExReleaseFastMutex(&Ccb->DataListLock);
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
DPRINT("NpfsRead done (Status %lx)\n", Status); DPRINT("NpfsRead done (Status %lx)\n", Status);
@ -568,19 +568,19 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
} }
if (Status == STATUS_PENDING) if (Status == STATUS_PENDING)
{ {
ExReleaseFastMutex(&Fcb->DataListLock); ExReleaseFastMutex(&Ccb->DataListLock);
DPRINT("NpfsRead done (Status %lx)\n", OriginalStatus); DPRINT("NpfsRead done (Status %lx)\n", OriginalStatus);
return OriginalStatus; return OriginalStatus;
} }
RemoveEntryList(&Context->ListEntry); RemoveEntryList(&Context->ListEntry);
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
if (IsListEmpty(&Fcb->ReadRequestListHead)) if (IsListEmpty(&Ccb->ReadRequestListHead))
{ {
ExReleaseFastMutex(&Fcb->DataListLock); ExReleaseFastMutex(&Ccb->DataListLock);
DPRINT("NpfsRead done (Status %lx)\n", OriginalStatus); DPRINT("NpfsRead done (Status %lx)\n", OriginalStatus);
return OriginalStatus; return OriginalStatus;
} }
Context = CONTAINING_RECORD(Fcb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry); Context = CONTAINING_RECORD(Ccb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry);
Irp = CONTAINING_RECORD(Context, IRP, Tail.Overlay.DriverContext); Irp = CONTAINING_RECORD(Context, IRP, Tail.Overlay.DriverContext);
} }
} }
@ -603,8 +603,8 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
{ {
PIO_STACK_LOCATION IoStack; PIO_STACK_LOCATION IoStack;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNPFS_FCB Fcb = NULL; PNPFS_CCB Ccb = NULL;
PNPFS_FCB ReaderFcb; PNPFS_CCB ReaderCcb;
PNPFS_PIPE Pipe = NULL; PNPFS_PIPE Pipe = NULL;
PUCHAR Buffer; PUCHAR Buffer;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
@ -621,9 +621,9 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
DPRINT("FileObject %p\n", FileObject); DPRINT("FileObject %p\n", FileObject);
DPRINT("Pipe name %wZ\n", &FileObject->FileName); DPRINT("Pipe name %wZ\n", &FileObject->FileName);
Fcb = FileObject->FsContext; Ccb = FileObject->FsContext2;
ReaderFcb = Fcb->OtherSide; ReaderCcb = Ccb->OtherSide;
Pipe = Fcb->Pipe; Pipe = Ccb->Pipe;
Length = IoStack->Parameters.Write.Length; Length = IoStack->Parameters.Write.Length;
Offset = IoStack->Parameters.Write.ByteOffset.u.LowPart; Offset = IoStack->Parameters.Write.ByteOffset.u.LowPart;
@ -637,12 +637,12 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
goto done; goto done;
} }
if (ReaderFcb == NULL) if (ReaderCcb == NULL)
{ {
DPRINT("Pipe is NOT connected!\n"); DPRINT("Pipe is NOT connected!\n");
if (Fcb->PipeState == FILE_PIPE_LISTENING_STATE) if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE)
Status = STATUS_PIPE_LISTENING; Status = STATUS_PIPE_LISTENING;
else if (Fcb->PipeState == FILE_PIPE_DISCONNECTED_STATE) else if (Ccb->PipeState == FILE_PIPE_DISCONNECTED_STATE)
Status = STATUS_PIPE_DISCONNECTED; Status = STATUS_PIPE_DISCONNECTED;
else else
Status = STATUS_UNSUCCESSFUL; Status = STATUS_UNSUCCESSFUL;
@ -650,7 +650,7 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
goto done; goto done;
} }
if (ReaderFcb->Data == NULL) if (ReaderCcb->Data == NULL)
{ {
DPRINT("Pipe is NOT writable!\n"); DPRINT("Pipe is NOT writable!\n");
Status = STATUS_UNSUCCESSFUL; Status = STATUS_UNSUCCESSFUL;
@ -661,7 +661,7 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
Buffer = MmGetSystemAddressForMdl (Irp->MdlAddress); Buffer = MmGetSystemAddressForMdl (Irp->MdlAddress);
ExAcquireFastMutex(&ReaderFcb->DataListLock); ExAcquireFastMutex(&ReaderCcb->DataListLock);
#ifndef NDEBUG #ifndef NDEBUG
DPRINT("Length %d Buffer %x Offset %x\n",Length,Buffer,Offset); DPRINT("Length %d Buffer %x Offset %x\n",Length,Buffer,Offset);
HexDump(Buffer, Length); HexDump(Buffer, Length);
@ -669,35 +669,35 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
while(1) while(1)
{ {
if (ReaderFcb->WriteQuotaAvailable == 0) if (ReaderCcb->WriteQuotaAvailable == 0)
{ {
KeSetEvent(&ReaderFcb->ReadEvent, IO_NO_INCREMENT, FALSE); KeSetEvent(&ReaderCcb->ReadEvent, IO_NO_INCREMENT, FALSE);
if (Fcb->PipeState != FILE_PIPE_CONNECTED_STATE) if (Ccb->PipeState != FILE_PIPE_CONNECTED_STATE)
{ {
Status = STATUS_PIPE_BROKEN; Status = STATUS_PIPE_BROKEN;
ExReleaseFastMutex(&ReaderFcb->DataListLock); ExReleaseFastMutex(&ReaderCcb->DataListLock);
goto done; goto done;
} }
ExReleaseFastMutex(&ReaderFcb->DataListLock); ExReleaseFastMutex(&ReaderCcb->DataListLock);
DPRINT("Waiting for buffer space (%S)\n", Pipe->PipeName.Buffer); DPRINT("Waiting for buffer space (%S)\n", Pipe->PipeName.Buffer);
Status = KeWaitForSingleObject(&Fcb->WriteEvent, Status = KeWaitForSingleObject(&Ccb->WriteEvent,
UserRequest, UserRequest,
KernelMode, KernelMode,
FALSE, FALSE,
NULL); NULL);
DPRINT("Finished waiting (%S)! Status: %x\n", Pipe->PipeName.Buffer, Status); DPRINT("Finished waiting (%S)! Status: %x\n", Pipe->PipeName.Buffer, Status);
ExAcquireFastMutex(&ReaderFcb->DataListLock); ExAcquireFastMutex(&ReaderCcb->DataListLock);
/* /*
* It's possible that the event was signaled because the * It's possible that the event was signaled because the
* other side of pipe was closed. * other side of pipe was closed.
*/ */
if (Fcb->PipeState != FILE_PIPE_CONNECTED_STATE) if (Ccb->PipeState != FILE_PIPE_CONNECTED_STATE)
{ {
DPRINT("PipeState: %x\n", Fcb->PipeState); DPRINT("PipeState: %x\n", Ccb->PipeState);
Status = STATUS_PIPE_BROKEN; Status = STATUS_PIPE_BROKEN;
ExReleaseFastMutex(&ReaderFcb->DataListLock); ExReleaseFastMutex(&ReaderCcb->DataListLock);
goto done; goto done;
} }
} }
@ -705,38 +705,38 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
if (Pipe->WriteMode == FILE_PIPE_BYTE_STREAM_MODE) if (Pipe->WriteMode == FILE_PIPE_BYTE_STREAM_MODE)
{ {
DPRINT("Byte stream mode\n"); DPRINT("Byte stream mode\n");
while (Length > 0 && ReaderFcb->WriteQuotaAvailable > 0) while (Length > 0 && ReaderCcb->WriteQuotaAvailable > 0)
{ {
CopyLength = min(Length, ReaderFcb->WriteQuotaAvailable); CopyLength = min(Length, ReaderCcb->WriteQuotaAvailable);
if ((ULONG_PTR)ReaderFcb->WritePtr + CopyLength <= (ULONG_PTR)ReaderFcb->Data + ReaderFcb->MaxDataLength) if ((ULONG_PTR)ReaderCcb->WritePtr + CopyLength <= (ULONG_PTR)ReaderCcb->Data + ReaderCcb->MaxDataLength)
{ {
memcpy(ReaderFcb->WritePtr, Buffer, CopyLength); memcpy(ReaderCcb->WritePtr, Buffer, CopyLength);
ReaderFcb->WritePtr = (PVOID)((ULONG_PTR)ReaderFcb->WritePtr + CopyLength); ReaderCcb->WritePtr = (PVOID)((ULONG_PTR)ReaderCcb->WritePtr + CopyLength);
if ((ULONG_PTR)ReaderFcb->WritePtr == (ULONG_PTR)ReaderFcb->Data + ReaderFcb->MaxDataLength) if ((ULONG_PTR)ReaderCcb->WritePtr == (ULONG_PTR)ReaderCcb->Data + ReaderCcb->MaxDataLength)
{ {
ReaderFcb->WritePtr = ReaderFcb->Data; ReaderCcb->WritePtr = ReaderCcb->Data;
} }
} }
else else
{ {
TempLength = (ULONG)((ULONG_PTR)ReaderFcb->Data + ReaderFcb->MaxDataLength - (ULONG_PTR)ReaderFcb->WritePtr); TempLength = (ULONG)((ULONG_PTR)ReaderCcb->Data + ReaderCcb->MaxDataLength - (ULONG_PTR)ReaderCcb->WritePtr);
memcpy(ReaderFcb->WritePtr, Buffer, TempLength); memcpy(ReaderCcb->WritePtr, Buffer, TempLength);
memcpy(ReaderFcb->Data, Buffer + TempLength, CopyLength - TempLength); memcpy(ReaderCcb->Data, Buffer + TempLength, CopyLength - TempLength);
ReaderFcb->WritePtr = (PVOID)((ULONG_PTR)ReaderFcb->Data + CopyLength - TempLength); ReaderCcb->WritePtr = (PVOID)((ULONG_PTR)ReaderCcb->Data + CopyLength - TempLength);
} }
Buffer += CopyLength; Buffer += CopyLength;
Length -= CopyLength; Length -= CopyLength;
Information += CopyLength; Information += CopyLength;
ReaderFcb->ReadDataAvailable += CopyLength; ReaderCcb->ReadDataAvailable += CopyLength;
ReaderFcb->WriteQuotaAvailable -= CopyLength; ReaderCcb->WriteQuotaAvailable -= CopyLength;
} }
if (Length == 0) if (Length == 0)
{ {
KeSetEvent(&ReaderFcb->ReadEvent, IO_NO_INCREMENT, FALSE); KeSetEvent(&ReaderCcb->ReadEvent, IO_NO_INCREMENT, FALSE);
KeResetEvent(&Fcb->WriteEvent); KeResetEvent(&Ccb->WriteEvent);
break; break;
} }
} }
@ -745,24 +745,24 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
DPRINT("Message mode\n"); DPRINT("Message mode\n");
if (Length > 0) if (Length > 0)
{ {
CopyLength = min(Length, ReaderFcb->WriteQuotaAvailable); CopyLength = min(Length, ReaderCcb->WriteQuotaAvailable);
memcpy(ReaderFcb->Data, Buffer, CopyLength); memcpy(ReaderCcb->Data, Buffer, CopyLength);
Information = CopyLength; Information = CopyLength;
ReaderFcb->ReadDataAvailable = CopyLength; ReaderCcb->ReadDataAvailable = CopyLength;
ReaderFcb->WriteQuotaAvailable = 0; ReaderCcb->WriteQuotaAvailable = 0;
} }
if (Information > 0) if (Information > 0)
{ {
KeSetEvent(&ReaderFcb->ReadEvent, IO_NO_INCREMENT, FALSE); KeSetEvent(&ReaderCcb->ReadEvent, IO_NO_INCREMENT, FALSE);
KeResetEvent(&Fcb->WriteEvent); KeResetEvent(&Ccb->WriteEvent);
break; break;
} }
} }
} }
ExReleaseFastMutex(&ReaderFcb->DataListLock); ExReleaseFastMutex(&ReaderCcb->DataListLock);
done: done:
Irp->IoStatus.Status = Status; Irp->IoStatus.Status = Status;