diff --git a/reactos/drivers/filesystems/npfs/create.c b/reactos/drivers/filesystems/npfs/create.c index d643b7c77ae..580b848fa02 100644 --- a/reactos/drivers/filesystems/npfs/create.c +++ b/reactos/drivers/filesystems/npfs/create.c @@ -1,10 +1,10 @@ /* - * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel - * FILE: drivers/fs/np/create.c - * PURPOSE: Named pipe filesystem - * PROGRAMMER: David Welch - */ +* COPYRIGHT: See COPYING in the top level directory +* PROJECT: ReactOS kernel +* FILE: drivers/fs/np/create.c +* PURPOSE: Named pipe filesystem +* PROGRAMMER: David Welch +*/ /* INCLUDES ******************************************************************/ @@ -17,754 +17,754 @@ static PNPFS_FCB NpfsFindPipe(PNPFS_DEVICE_EXTENSION DeviceExt, - PUNICODE_STRING PipeName) + PUNICODE_STRING PipeName) { - PLIST_ENTRY CurrentEntry; - PNPFS_FCB Fcb; + PLIST_ENTRY CurrentEntry; + PNPFS_FCB Fcb; - CurrentEntry = DeviceExt->PipeListHead.Flink; - while (CurrentEntry != &DeviceExt->PipeListHead) - { - Fcb = CONTAINING_RECORD(CurrentEntry, NPFS_FCB, PipeListEntry); - if (RtlCompareUnicodeString(PipeName, - &Fcb->PipeName, - TRUE) == 0) + CurrentEntry = DeviceExt->PipeListHead.Flink; + while (CurrentEntry != &DeviceExt->PipeListHead) { - DPRINT("<%wZ> = <%wZ>\n", PipeName, &Fcb->PipeName); - return Fcb; + Fcb = CONTAINING_RECORD(CurrentEntry, NPFS_FCB, PipeListEntry); + if (RtlCompareUnicodeString(PipeName, + &Fcb->PipeName, + TRUE) == 0) + { + DPRINT("<%wZ> = <%wZ>\n", PipeName, &Fcb->PipeName); + return Fcb; + } + + CurrentEntry = CurrentEntry->Flink; } - CurrentEntry = CurrentEntry->Flink; - } - - return NULL; + return NULL; } static PNPFS_CCB NpfsFindListeningServerInstance(PNPFS_FCB Fcb) { - PLIST_ENTRY CurrentEntry; - PNPFS_WAITER_ENTRY Waiter; - KIRQL oldIrql; - PIRP Irp; + PLIST_ENTRY CurrentEntry; + PNPFS_WAITER_ENTRY Waiter; + KIRQL oldIrql; + PIRP Irp; - CurrentEntry = Fcb->WaiterListHead.Flink; - while (CurrentEntry != &Fcb->WaiterListHead) - { - Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry); - Irp = CONTAINING_RECORD(Waiter, IRP, Tail.Overlay.DriverContext); - if (Waiter->Ccb->PipeState == FILE_PIPE_LISTENING_STATE) + CurrentEntry = Fcb->WaiterListHead.Flink; + while (CurrentEntry != &Fcb->WaiterListHead) { - DPRINT("Server found! CCB %p\n", Waiter->Ccb); + Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry); + Irp = CONTAINING_RECORD(Waiter, IRP, Tail.Overlay.DriverContext); + if (Waiter->Ccb->PipeState == FILE_PIPE_LISTENING_STATE) + { + DPRINT("Server found! CCB %p\n", Waiter->Ccb); - IoAcquireCancelSpinLock(&oldIrql); - if (!Irp->Cancel) - { - (void)IoSetCancelRoutine(Irp, NULL); - IoReleaseCancelSpinLock(oldIrql); - return Waiter->Ccb; - } - IoReleaseCancelSpinLock(oldIrql); + IoAcquireCancelSpinLock(&oldIrql); + if (!Irp->Cancel) + { + (void)IoSetCancelRoutine(Irp, NULL); + IoReleaseCancelSpinLock(oldIrql); + return Waiter->Ccb; + } + IoReleaseCancelSpinLock(oldIrql); + } + + CurrentEntry = CurrentEntry->Flink; } - CurrentEntry = CurrentEntry->Flink; - } - - return NULL; + return NULL; } static VOID NpfsSignalAndRemoveListeningServerInstance(PNPFS_FCB Fcb, - PNPFS_CCB Ccb) + PNPFS_CCB Ccb) { - PLIST_ENTRY CurrentEntry; - PNPFS_WAITER_ENTRY Waiter; - PIRP Irp; + PLIST_ENTRY CurrentEntry; + PNPFS_WAITER_ENTRY Waiter; + PIRP Irp; - CurrentEntry = Fcb->WaiterListHead.Flink; - while (CurrentEntry != &Fcb->WaiterListHead) - { - Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry); - if (Waiter->Ccb == Ccb) + CurrentEntry = Fcb->WaiterListHead.Flink; + while (CurrentEntry != &Fcb->WaiterListHead) { - DPRINT("Server found! CCB %p\n", Waiter->Ccb); + Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry); + if (Waiter->Ccb == Ccb) + { + DPRINT("Server found! CCB %p\n", Waiter->Ccb); - RemoveEntryList(&Waiter->Entry); - Irp = CONTAINING_RECORD(Waiter, IRP, Tail.Overlay.DriverContext); - Irp->IoStatus.Status = STATUS_SUCCESS; - Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - break; + RemoveEntryList(&Waiter->Entry); + Irp = CONTAINING_RECORD(Waiter, IRP, Tail.Overlay.DriverContext); + Irp->IoStatus.Status = STATUS_SUCCESS; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + break; + } + CurrentEntry = CurrentEntry->Flink; } - CurrentEntry = CurrentEntry->Flink; - } } NTSTATUS STDCALL NpfsCreate(PDEVICE_OBJECT DeviceObject, - PIRP Irp) + PIRP Irp) { - PEXTENDED_IO_STACK_LOCATION IoStack; - PFILE_OBJECT FileObject; - PNPFS_FCB Fcb; - PNPFS_CCB ClientCcb; - PNPFS_CCB ServerCcb = NULL; - PNPFS_DEVICE_EXTENSION DeviceExt; - BOOLEAN SpecialAccess; - ACCESS_MASK DesiredAccess; + PEXTENDED_IO_STACK_LOCATION IoStack; + PFILE_OBJECT FileObject; + PNPFS_FCB Fcb; + PNPFS_CCB ClientCcb; + PNPFS_CCB ServerCcb = NULL; + PNPFS_DEVICE_EXTENSION DeviceExt; + BOOLEAN SpecialAccess; + ACCESS_MASK DesiredAccess; - DPRINT("NpfsCreate(DeviceObject %p Irp %p)\n", DeviceObject, Irp); + DPRINT("NpfsCreate(DeviceObject %p Irp %p)\n", DeviceObject, Irp); - DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; - IoStack = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation(Irp); - FileObject = IoStack->FileObject; - DesiredAccess = IoStack->Parameters.CreatePipe.SecurityContext->DesiredAccess; - DPRINT("FileObject %p\n", FileObject); - DPRINT("FileName %wZ\n", &FileObject->FileName); + DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; + IoStack = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation(Irp); + FileObject = IoStack->FileObject; + DesiredAccess = IoStack->Parameters.CreatePipe.SecurityContext->DesiredAccess; + DPRINT("FileObject %p\n", FileObject); + DPRINT("FileName %wZ\n", &FileObject->FileName); - Irp->IoStatus.Information = 0; + Irp->IoStatus.Information = 0; - SpecialAccess = ((DesiredAccess & SPECIFIC_RIGHTS_ALL) == FILE_READ_ATTRIBUTES); - if (SpecialAccess) - { - DPRINT("NpfsCreate() open client end for special use!\n"); - } + SpecialAccess = ((DesiredAccess & SPECIFIC_RIGHTS_ALL) == FILE_READ_ATTRIBUTES); + if (SpecialAccess) + { + DPRINT("NpfsCreate() open client end for special use!\n"); + } - /* - * Step 1. Find the pipe we're trying to open. - */ - KeLockMutex(&DeviceExt->PipeListLock); - Fcb = NpfsFindPipe(DeviceExt, - &FileObject->FileName); - if (Fcb == NULL) - { - /* Not found, bail out with error. */ - DPRINT("No pipe found!\n"); - KeUnlockMutex(&DeviceExt->PipeListLock); - Irp->IoStatus.Status = STATUS_OBJECT_NAME_NOT_FOUND; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_OBJECT_NAME_NOT_FOUND; - } + /* + * Step 1. Find the pipe we're trying to open. + */ + KeLockMutex(&DeviceExt->PipeListLock); + Fcb = NpfsFindPipe(DeviceExt, + &FileObject->FileName); + if (Fcb == NULL) + { + /* Not found, bail out with error. */ + DPRINT("No pipe found!\n"); + KeUnlockMutex(&DeviceExt->PipeListLock); + Irp->IoStatus.Status = STATUS_OBJECT_NAME_NOT_FOUND; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_OBJECT_NAME_NOT_FOUND; + } - KeUnlockMutex(&DeviceExt->PipeListLock); + KeUnlockMutex(&DeviceExt->PipeListLock); - /* - * Acquire the lock for CCB lists. From now on no modifications to the - * CCB lists are allowed, because it can cause various misconsistencies. - */ - KeLockMutex(&Fcb->CcbListLock); + /* + * Acquire the lock for CCB lists. From now on no modifications to the + * CCB lists are allowed, because it can cause various misconsistencies. + */ + KeLockMutex(&Fcb->CcbListLock); - /* - * Step 2. Create the client CCB. - */ - ClientCcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_CCB)); - if (ClientCcb == NULL) - { - DPRINT("No memory!\n"); - KeUnlockMutex(&Fcb->CcbListLock); - Irp->IoStatus.Status = STATUS_NO_MEMORY; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_NO_MEMORY; - } + /* + * Step 2. Create the client CCB. + */ + ClientCcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_CCB)); + if (ClientCcb == NULL) + { + DPRINT("No memory!\n"); + KeUnlockMutex(&Fcb->CcbListLock); + Irp->IoStatus.Status = STATUS_NO_MEMORY; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_NO_MEMORY; + } - ClientCcb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread; - ClientCcb->Fcb = Fcb; - ClientCcb->PipeEnd = FILE_PIPE_CLIENT_END; - ClientCcb->OtherSide = NULL; - ClientCcb->PipeState = SpecialAccess ? 0 : FILE_PIPE_DISCONNECTED_STATE; - InitializeListHead(&ClientCcb->ReadRequestListHead); + ClientCcb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread; + ClientCcb->Fcb = Fcb; + ClientCcb->PipeEnd = FILE_PIPE_CLIENT_END; + ClientCcb->OtherSide = NULL; + ClientCcb->PipeState = SpecialAccess ? 0 : FILE_PIPE_DISCONNECTED_STATE; + InitializeListHead(&ClientCcb->ReadRequestListHead); - DPRINT("CCB: %p\n", ClientCcb); + DPRINT("CCB: %p\n", ClientCcb); - /* Initialize data list. */ - if (Fcb->OutboundQuota) - { - ClientCcb->Data = ExAllocatePool(PagedPool, Fcb->OutboundQuota); - if (ClientCcb->Data == NULL) - { - DPRINT("No memory!\n"); - ExFreePool(ClientCcb); - KeUnlockMutex(&Fcb->CcbListLock); - Irp->IoStatus.Status = STATUS_NO_MEMORY; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_NO_MEMORY; - } - } - else - { - ClientCcb->Data = NULL; - } + /* Initialize data list. */ + if (Fcb->OutboundQuota) + { + ClientCcb->Data = ExAllocatePool(PagedPool, Fcb->OutboundQuota); + if (ClientCcb->Data == NULL) + { + DPRINT("No memory!\n"); + ExFreePool(ClientCcb); + KeUnlockMutex(&Fcb->CcbListLock); + Irp->IoStatus.Status = STATUS_NO_MEMORY; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_NO_MEMORY; + } + } + else + { + ClientCcb->Data = NULL; + } - ClientCcb->ReadPtr = ClientCcb->Data; - ClientCcb->WritePtr = ClientCcb->Data; - ClientCcb->ReadDataAvailable = 0; - ClientCcb->WriteQuotaAvailable = Fcb->OutboundQuota; - ClientCcb->MaxDataLength = Fcb->OutboundQuota; - ExInitializeFastMutex(&ClientCcb->DataListLock); - KeInitializeEvent(&ClientCcb->ConnectEvent, SynchronizationEvent, FALSE); - KeInitializeEvent(&ClientCcb->ReadEvent, SynchronizationEvent, FALSE); - KeInitializeEvent(&ClientCcb->WriteEvent, SynchronizationEvent, FALSE); + ClientCcb->ReadPtr = ClientCcb->Data; + ClientCcb->WritePtr = ClientCcb->Data; + ClientCcb->ReadDataAvailable = 0; + ClientCcb->WriteQuotaAvailable = Fcb->OutboundQuota; + ClientCcb->MaxDataLength = Fcb->OutboundQuota; + ExInitializeFastMutex(&ClientCcb->DataListLock); + KeInitializeEvent(&ClientCcb->ConnectEvent, SynchronizationEvent, FALSE); + KeInitializeEvent(&ClientCcb->ReadEvent, SynchronizationEvent, FALSE); + KeInitializeEvent(&ClientCcb->WriteEvent, SynchronizationEvent, FALSE); - /* - * Step 3. Search for listening server CCB. - */ + /* + * Step 3. Search for listening server CCB. + */ - if (!SpecialAccess) - { - /* - * WARNING: Point of no return! Once we get the server CCB it's - * possible that we completed a wait request and so we have to - * complete even this request. - */ + if (!SpecialAccess) + { + /* + * WARNING: Point of no return! Once we get the server CCB it's + * possible that we completed a wait request and so we have to + * complete even this request. + */ - ServerCcb = NpfsFindListeningServerInstance(Fcb); - if (ServerCcb == NULL) - { - PLIST_ENTRY CurrentEntry; - PNPFS_CCB Ccb; + ServerCcb = NpfsFindListeningServerInstance(Fcb); + if (ServerCcb == NULL) + { + PLIST_ENTRY CurrentEntry; + PNPFS_CCB Ccb; - /* - * If no waiting server CCB was found then try to pick - * one of the listing server CCB on the pipe. - */ + /* + * If no waiting server CCB was found then try to pick + * one of the listing server CCB on the pipe. + */ - CurrentEntry = Fcb->ServerCcbListHead.Flink; - while (CurrentEntry != &Fcb->ServerCcbListHead) - { - Ccb = CONTAINING_RECORD(CurrentEntry, NPFS_CCB, CcbListEntry); - if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE) - { - ServerCcb = Ccb; - break; - } - CurrentEntry = CurrentEntry->Flink; - } + CurrentEntry = Fcb->ServerCcbListHead.Flink; + while (CurrentEntry != &Fcb->ServerCcbListHead) + { + Ccb = CONTAINING_RECORD(CurrentEntry, NPFS_CCB, CcbListEntry); + if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE) + { + ServerCcb = Ccb; + break; + } + CurrentEntry = CurrentEntry->Flink; + } - /* - * No one is listening to me?! I'm so lonely... :( - */ + /* + * No one is listening to me?! I'm so lonely... :( + */ - if (ServerCcb == NULL) - { - /* Not found, bail out with error for FILE_OPEN requests. */ - DPRINT("No listening server CCB found!\n"); - if (ClientCcb->Data) - ExFreePool(ClientCcb->Data); - KeUnlockMutex(&Fcb->CcbListLock); - Irp->IoStatus.Status = STATUS_PIPE_BUSY; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_PIPE_BUSY; - } - } - else - { - /* Signal the server thread and remove it from the waiter list */ - /* FIXME: Merge this with the NpfsFindListeningServerInstance routine. */ - NpfsSignalAndRemoveListeningServerInstance(Fcb, ServerCcb); - } - } - else if (IsListEmpty(&Fcb->ServerCcbListHead)) - { - DPRINT("No server fcb found!\n"); - KeUnlockMutex(&Fcb->CcbListLock); - Irp->IoStatus.Status = STATUS_UNSUCCESSFUL; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_UNSUCCESSFUL; - } + if (ServerCcb == NULL) + { + /* Not found, bail out with error for FILE_OPEN requests. */ + DPRINT("No listening server CCB found!\n"); + if (ClientCcb->Data) + ExFreePool(ClientCcb->Data); + KeUnlockMutex(&Fcb->CcbListLock); + Irp->IoStatus.Status = STATUS_PIPE_BUSY; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_PIPE_BUSY; + } + } + else + { + /* Signal the server thread and remove it from the waiter list */ + /* FIXME: Merge this with the NpfsFindListeningServerInstance routine. */ + NpfsSignalAndRemoveListeningServerInstance(Fcb, ServerCcb); + } + } + else if (IsListEmpty(&Fcb->ServerCcbListHead)) + { + DPRINT("No server fcb found!\n"); + KeUnlockMutex(&Fcb->CcbListLock); + Irp->IoStatus.Status = STATUS_UNSUCCESSFUL; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_UNSUCCESSFUL; + } - /* - * Step 4. Add the client CCB to a list and connect it if possible. - */ + /* + * Step 4. Add the client CCB to a list and connect it if possible. + */ - /* Add the client CCB to the pipe CCB list. */ - InsertTailList(&Fcb->ClientCcbListHead, &ClientCcb->CcbListEntry); + /* Add the client CCB to the pipe CCB list. */ + InsertTailList(&Fcb->ClientCcbListHead, &ClientCcb->CcbListEntry); - /* Connect to listening server side */ - if (ServerCcb) - { - ClientCcb->OtherSide = ServerCcb; - ServerCcb->OtherSide = ClientCcb; - ClientCcb->PipeState = FILE_PIPE_CONNECTED_STATE; - ServerCcb->PipeState = FILE_PIPE_CONNECTED_STATE; - KeSetEvent(&ServerCcb->ConnectEvent, IO_NO_INCREMENT, FALSE); - } + /* Connect to listening server side */ + if (ServerCcb) + { + ClientCcb->OtherSide = ServerCcb; + ServerCcb->OtherSide = ClientCcb; + ClientCcb->PipeState = FILE_PIPE_CONNECTED_STATE; + ServerCcb->PipeState = FILE_PIPE_CONNECTED_STATE; + KeSetEvent(&ServerCcb->ConnectEvent, IO_NO_INCREMENT, FALSE); + } - KeUnlockMutex(&Fcb->CcbListLock); + KeUnlockMutex(&Fcb->CcbListLock); - FileObject->FsContext = Fcb; - FileObject->FsContext2 = ClientCcb; - FileObject->Flags |= FO_NAMED_PIPE; + FileObject->FsContext = Fcb; + FileObject->FsContext2 = ClientCcb; + FileObject->Flags |= FO_NAMED_PIPE; - Irp->IoStatus.Status = STATUS_SUCCESS; - IoCompleteRequest(Irp, IO_NO_INCREMENT); + Irp->IoStatus.Status = STATUS_SUCCESS; + IoCompleteRequest(Irp, IO_NO_INCREMENT); - DPRINT("Success!\n"); + DPRINT("Success!\n"); - return STATUS_SUCCESS; + return STATUS_SUCCESS; } NTSTATUS STDCALL NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject, - PIRP Irp) + PIRP Irp) { - PEXTENDED_IO_STACK_LOCATION IoStack; - PFILE_OBJECT FileObject; - PNPFS_DEVICE_EXTENSION DeviceExt; - PNPFS_FCB Fcb; - PNPFS_CCB Ccb; - PNAMED_PIPE_CREATE_PARAMETERS Buffer; - BOOLEAN NewPipe = FALSE; + PEXTENDED_IO_STACK_LOCATION IoStack; + PFILE_OBJECT FileObject; + PNPFS_DEVICE_EXTENSION DeviceExt; + PNPFS_FCB Fcb; + PNPFS_CCB Ccb; + PNAMED_PIPE_CREATE_PARAMETERS Buffer; + BOOLEAN NewPipe = FALSE; - DPRINT("NpfsCreateNamedPipe(DeviceObject %p Irp %p)\n", DeviceObject, Irp); + DPRINT("NpfsCreateNamedPipe(DeviceObject %p Irp %p)\n", DeviceObject, Irp); - DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; - IoStack = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation(Irp); - FileObject = IoStack->FileObject; - DPRINT("FileObject %p\n", FileObject); - DPRINT("Pipe name %wZ\n", &FileObject->FileName); + DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; + IoStack = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation(Irp); + FileObject = IoStack->FileObject; + DPRINT("FileObject %p\n", FileObject); + DPRINT("Pipe name %wZ\n", &FileObject->FileName); - Buffer = IoStack->Parameters.CreatePipe.Parameters; + Buffer = IoStack->Parameters.CreatePipe.Parameters; - Irp->IoStatus.Information = 0; + Irp->IoStatus.Information = 0; - if (!(IoStack->Parameters.CreatePipe.ShareAccess & (FILE_SHARE_READ|FILE_SHARE_WRITE)) || - (IoStack->Parameters.CreatePipe.ShareAccess & ~(FILE_SHARE_READ|FILE_SHARE_WRITE))) - { - Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; + if (!(IoStack->Parameters.CreatePipe.ShareAccess & (FILE_SHARE_READ|FILE_SHARE_WRITE)) || + (IoStack->Parameters.CreatePipe.ShareAccess & ~(FILE_SHARE_READ|FILE_SHARE_WRITE))) + { + Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_INVALID_PARAMETER; + } + + Ccb = ExAllocatePool(NonPagedPool, sizeof(NPFS_CCB)); + if (Ccb == NULL) + { + Irp->IoStatus.Status = STATUS_NO_MEMORY; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_NO_MEMORY; + } + + Ccb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread; + KeLockMutex(&DeviceExt->PipeListLock); + + /* + * First search for existing Pipe with the same name. + */ + Fcb = NpfsFindPipe(DeviceExt, + &FileObject->FileName); + if (Fcb != NULL) + { + /* + * Found Pipe with the same name. Check if we are + * allowed to use it. + */ + KeUnlockMutex(&DeviceExt->PipeListLock); + + if (Fcb->CurrentInstances >= Fcb->MaximumInstances) + { + DPRINT("Out of instances.\n"); + ExFreePool(Ccb); + Irp->IoStatus.Status = STATUS_PIPE_BUSY; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_PIPE_BUSY; + } + + /* FIXME: Check pipe modes also! */ + if (Fcb->MaximumInstances != Buffer->MaximumInstances || + Fcb->TimeOut.QuadPart != Buffer->DefaultTimeout.QuadPart) + { + DPRINT("Asked for invalid pipe mode.\n"); + ExFreePool(Ccb); + Irp->IoStatus.Status = STATUS_ACCESS_DENIED; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_ACCESS_DENIED; + } + } + else + { + NewPipe = TRUE; + Fcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_FCB)); + if (Fcb == NULL) + { + KeUnlockMutex(&DeviceExt->PipeListLock); + ExFreePool(Ccb); + Irp->IoStatus.Status = STATUS_NO_MEMORY; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_NO_MEMORY; + } + + Fcb->PipeName.Length = FileObject->FileName.Length; + Fcb->PipeName.MaximumLength = Fcb->PipeName.Length + sizeof(UNICODE_NULL); + Fcb->PipeName.Buffer = ExAllocatePool(NonPagedPool, Fcb->PipeName.MaximumLength); + if (Fcb->PipeName.Buffer == NULL) + { + KeUnlockMutex(&DeviceExt->PipeListLock); + ExFreePool(Fcb); + ExFreePool(Ccb); + Irp->IoStatus.Status = STATUS_NO_MEMORY; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_NO_MEMORY; + } + + RtlCopyUnicodeString(&Fcb->PipeName, &FileObject->FileName); + + InitializeListHead(&Fcb->ServerCcbListHead); + InitializeListHead(&Fcb->ClientCcbListHead); + InitializeListHead(&Fcb->WaiterListHead); + KeInitializeMutex(&Fcb->CcbListLock, 0); + + Fcb->PipeType = Buffer->NamedPipeType; + Fcb->WriteMode = Buffer->ReadMode; + Fcb->ReadMode = Buffer->ReadMode; + Fcb->CompletionMode = Buffer->CompletionMode; + switch (IoStack->Parameters.CreatePipe.ShareAccess & (FILE_SHARE_READ|FILE_SHARE_WRITE)) + { + case FILE_SHARE_READ: + Fcb->PipeConfiguration = FILE_PIPE_OUTBOUND; + break; + case FILE_SHARE_WRITE: + Fcb->PipeConfiguration = FILE_PIPE_INBOUND; + break; + case FILE_SHARE_READ|FILE_SHARE_WRITE: + Fcb->PipeConfiguration = FILE_PIPE_FULL_DUPLEX; + break; + } + Fcb->MaximumInstances = Buffer->MaximumInstances; + Fcb->CurrentInstances = 0; + Fcb->TimeOut = Buffer->DefaultTimeout; + if (!(Fcb->PipeConfiguration & FILE_PIPE_OUTBOUND) || + Fcb->PipeConfiguration & FILE_PIPE_FULL_DUPLEX) + { + if (Buffer->InboundQuota == 0) + { + Fcb->InboundQuota = DeviceExt->DefaultQuota; + } + else + { + Fcb->InboundQuota = PAGE_ROUND_UP(Buffer->InboundQuota); + if (Fcb->InboundQuota < DeviceExt->MinQuota) + { + Fcb->InboundQuota = DeviceExt->MinQuota; + } + else if (Fcb->InboundQuota > DeviceExt->MaxQuota) + { + Fcb->InboundQuota = DeviceExt->MaxQuota; + } + } + } + else + { + Fcb->InboundQuota = 0; + } + + if (Fcb->PipeConfiguration & (FILE_PIPE_FULL_DUPLEX|FILE_PIPE_OUTBOUND)) + { + if (Buffer->OutboundQuota == 0) + { + Fcb->OutboundQuota = DeviceExt->DefaultQuota; + } + else + { + Fcb->OutboundQuota = PAGE_ROUND_UP(Buffer->OutboundQuota); + if (Fcb->OutboundQuota < DeviceExt->MinQuota) + { + Fcb->OutboundQuota = DeviceExt->MinQuota; + } + else if (Fcb->OutboundQuota > DeviceExt->MaxQuota) + { + Fcb->OutboundQuota = DeviceExt->MaxQuota; + } + } + } + else + { + Fcb->OutboundQuota = 0; + } + + InsertTailList(&DeviceExt->PipeListHead, &Fcb->PipeListEntry); + KeUnlockMutex(&DeviceExt->PipeListLock); + } + + if (Fcb->InboundQuota) + { + Ccb->Data = ExAllocatePool(PagedPool, Fcb->InboundQuota); + if (Ccb->Data == NULL) + { + ExFreePool(Ccb); + + if (NewPipe) + { + KeLockMutex(&DeviceExt->PipeListLock); + RemoveEntryList(&Fcb->PipeListEntry); + KeUnlockMutex(&DeviceExt->PipeListLock); + RtlFreeUnicodeString(&Fcb->PipeName); + ExFreePool(Fcb); + } + + Irp->IoStatus.Status = STATUS_NO_MEMORY; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_NO_MEMORY; + } + } + else + { + Ccb->Data = NULL; + } + + Ccb->ReadPtr = Ccb->Data; + Ccb->WritePtr = Ccb->Data; + Ccb->ReadDataAvailable = 0; + Ccb->WriteQuotaAvailable = Fcb->InboundQuota; + Ccb->MaxDataLength = Fcb->InboundQuota; + InitializeListHead(&Ccb->ReadRequestListHead); + ExInitializeFastMutex(&Ccb->DataListLock); + + Fcb->CurrentInstances++; + + Ccb->Fcb = Fcb; + Ccb->PipeEnd = FILE_PIPE_SERVER_END; + Ccb->PipeState = FILE_PIPE_LISTENING_STATE; + Ccb->OtherSide = NULL; + + DPRINT("CCB: %x\n", Ccb); + + KeInitializeEvent(&Ccb->ConnectEvent, SynchronizationEvent, FALSE); + KeInitializeEvent(&Ccb->ReadEvent, SynchronizationEvent, FALSE); + KeInitializeEvent(&Ccb->WriteEvent, SynchronizationEvent, FALSE); + + KeLockMutex(&Fcb->CcbListLock); + InsertTailList(&Fcb->ServerCcbListHead, &Ccb->CcbListEntry); + KeUnlockMutex(&Fcb->CcbListLock); + + FileObject->FsContext = Fcb; + FileObject->FsContext2 = Ccb; + FileObject->Flags |= FO_NAMED_PIPE; + + Irp->IoStatus.Status = STATUS_SUCCESS; IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_INVALID_PARAMETER; - } - Ccb = ExAllocatePool(NonPagedPool, sizeof(NPFS_CCB)); - if (Ccb == NULL) - { - Irp->IoStatus.Status = STATUS_NO_MEMORY; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_NO_MEMORY; - } + DPRINT("Success!\n"); - Ccb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread; - KeLockMutex(&DeviceExt->PipeListLock); - - /* - * First search for existing Pipe with the same name. - */ - Fcb = NpfsFindPipe(DeviceExt, - &FileObject->FileName); - if (Fcb != NULL) - { - /* - * Found Pipe with the same name. Check if we are - * allowed to use it. - */ - KeUnlockMutex(&DeviceExt->PipeListLock); - - if (Fcb->CurrentInstances >= Fcb->MaximumInstances) - { - DPRINT("Out of instances.\n"); - ExFreePool(Ccb); - Irp->IoStatus.Status = STATUS_PIPE_BUSY; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_PIPE_BUSY; - } - - /* FIXME: Check pipe modes also! */ - if (Fcb->MaximumInstances != Buffer->MaximumInstances || - Fcb->TimeOut.QuadPart != Buffer->DefaultTimeout.QuadPart) - { - DPRINT("Asked for invalid pipe mode.\n"); - ExFreePool(Ccb); - Irp->IoStatus.Status = STATUS_ACCESS_DENIED; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_ACCESS_DENIED; - } - } - else - { - NewPipe = TRUE; - Fcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_FCB)); - if (Fcb == NULL) - { - KeUnlockMutex(&DeviceExt->PipeListLock); - ExFreePool(Ccb); - Irp->IoStatus.Status = STATUS_NO_MEMORY; - Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_NO_MEMORY; - } - - Fcb->PipeName.Length = FileObject->FileName.Length; - Fcb->PipeName.MaximumLength = Fcb->PipeName.Length + sizeof(UNICODE_NULL); - Fcb->PipeName.Buffer = ExAllocatePool(NonPagedPool, Fcb->PipeName.MaximumLength); - if (Fcb->PipeName.Buffer == NULL) - { - KeUnlockMutex(&DeviceExt->PipeListLock); - ExFreePool(Fcb); - ExFreePool(Ccb); - Irp->IoStatus.Status = STATUS_NO_MEMORY; - Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_NO_MEMORY; - } - - RtlCopyUnicodeString(&Fcb->PipeName, &FileObject->FileName); - - InitializeListHead(&Fcb->ServerCcbListHead); - InitializeListHead(&Fcb->ClientCcbListHead); - InitializeListHead(&Fcb->WaiterListHead); - KeInitializeMutex(&Fcb->CcbListLock, 0); - - Fcb->PipeType = Buffer->NamedPipeType; - Fcb->WriteMode = Buffer->ReadMode; - Fcb->ReadMode = Buffer->ReadMode; - Fcb->CompletionMode = Buffer->CompletionMode; - switch (IoStack->Parameters.CreatePipe.ShareAccess & (FILE_SHARE_READ|FILE_SHARE_WRITE)) - { - case FILE_SHARE_READ: - Fcb->PipeConfiguration = FILE_PIPE_OUTBOUND; - break; - case FILE_SHARE_WRITE: - Fcb->PipeConfiguration = FILE_PIPE_INBOUND; - break; - case FILE_SHARE_READ|FILE_SHARE_WRITE: - Fcb->PipeConfiguration = FILE_PIPE_FULL_DUPLEX; - break; - } - Fcb->MaximumInstances = Buffer->MaximumInstances; - Fcb->CurrentInstances = 0; - Fcb->TimeOut = Buffer->DefaultTimeout; - if (!(Fcb->PipeConfiguration & FILE_PIPE_OUTBOUND) || - Fcb->PipeConfiguration & FILE_PIPE_FULL_DUPLEX) - { - if (Buffer->InboundQuota == 0) - { - Fcb->InboundQuota = DeviceExt->DefaultQuota; - } - else - { - Fcb->InboundQuota = PAGE_ROUND_UP(Buffer->InboundQuota); - if (Fcb->InboundQuota < DeviceExt->MinQuota) - { - Fcb->InboundQuota = DeviceExt->MinQuota; - } - else if (Fcb->InboundQuota > DeviceExt->MaxQuota) - { - Fcb->InboundQuota = DeviceExt->MaxQuota; - } - } - } - else - { - Fcb->InboundQuota = 0; - } - - if (Fcb->PipeConfiguration & (FILE_PIPE_FULL_DUPLEX|FILE_PIPE_OUTBOUND)) - { - if (Buffer->OutboundQuota == 0) - { - Fcb->OutboundQuota = DeviceExt->DefaultQuota; - } - else - { - Fcb->OutboundQuota = PAGE_ROUND_UP(Buffer->OutboundQuota); - if (Fcb->OutboundQuota < DeviceExt->MinQuota) - { - Fcb->OutboundQuota = DeviceExt->MinQuota; - } - else if (Fcb->OutboundQuota > DeviceExt->MaxQuota) - { - Fcb->OutboundQuota = DeviceExt->MaxQuota; - } - } - } - else - { - Fcb->OutboundQuota = 0; - } - - InsertTailList(&DeviceExt->PipeListHead, &Fcb->PipeListEntry); - KeUnlockMutex(&DeviceExt->PipeListLock); - } - - if (Fcb->InboundQuota) - { - Ccb->Data = ExAllocatePool(PagedPool, Fcb->InboundQuota); - if (Ccb->Data == NULL) - { - ExFreePool(Ccb); - - if (NewPipe) - { - KeLockMutex(&DeviceExt->PipeListLock); - RemoveEntryList(&Fcb->PipeListEntry); - KeUnlockMutex(&DeviceExt->PipeListLock); - RtlFreeUnicodeString(&Fcb->PipeName); - ExFreePool(Fcb); - } - - Irp->IoStatus.Status = STATUS_NO_MEMORY; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_NO_MEMORY; - } - } - else - { - Ccb->Data = NULL; - } - - Ccb->ReadPtr = Ccb->Data; - Ccb->WritePtr = Ccb->Data; - Ccb->ReadDataAvailable = 0; - Ccb->WriteQuotaAvailable = Fcb->InboundQuota; - Ccb->MaxDataLength = Fcb->InboundQuota; - InitializeListHead(&Ccb->ReadRequestListHead); - ExInitializeFastMutex(&Ccb->DataListLock); - - Fcb->CurrentInstances++; - - Ccb->Fcb = Fcb; - Ccb->PipeEnd = FILE_PIPE_SERVER_END; - Ccb->PipeState = FILE_PIPE_LISTENING_STATE; - Ccb->OtherSide = NULL; - - DPRINT("CCB: %x\n", Ccb); - - KeInitializeEvent(&Ccb->ConnectEvent, SynchronizationEvent, FALSE); - KeInitializeEvent(&Ccb->ReadEvent, SynchronizationEvent, FALSE); - KeInitializeEvent(&Ccb->WriteEvent, SynchronizationEvent, FALSE); - - KeLockMutex(&Fcb->CcbListLock); - InsertTailList(&Fcb->ServerCcbListHead, &Ccb->CcbListEntry); - KeUnlockMutex(&Fcb->CcbListLock); - - FileObject->FsContext = Fcb; - FileObject->FsContext2 = Ccb; - FileObject->Flags |= FO_NAMED_PIPE; - - Irp->IoStatus.Status = STATUS_SUCCESS; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - - DPRINT("Success!\n"); - - return STATUS_SUCCESS; + return STATUS_SUCCESS; } NTSTATUS STDCALL NpfsCleanup(PDEVICE_OBJECT DeviceObject, - PIRP Irp) + PIRP Irp) { - PNPFS_DEVICE_EXTENSION DeviceExt; - PIO_STACK_LOCATION IoStack; - PFILE_OBJECT FileObject; - PNPFS_CCB Ccb, OtherSide; - PNPFS_FCB Fcb; - BOOLEAN Server; + PNPFS_DEVICE_EXTENSION DeviceExt; + PIO_STACK_LOCATION IoStack; + PFILE_OBJECT FileObject; + PNPFS_CCB Ccb, OtherSide; + PNPFS_FCB Fcb; + BOOLEAN Server; - DPRINT("NpfsCleanup(DeviceObject %p Irp %p)\n", DeviceObject, Irp); + DPRINT("NpfsCleanup(DeviceObject %p Irp %p)\n", DeviceObject, Irp); - IoStack = IoGetCurrentIrpStackLocation(Irp); - DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; - FileObject = IoStack->FileObject; - Ccb = FileObject->FsContext2; + IoStack = IoGetCurrentIrpStackLocation(Irp); + DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; + FileObject = IoStack->FileObject; + Ccb = FileObject->FsContext2; - if (Ccb == NULL) - { - DPRINT("Success!\n"); - Irp->IoStatus.Status = STATUS_SUCCESS; - Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_SUCCESS; - } + if (Ccb == NULL) + { + DPRINT("Success!\n"); + Irp->IoStatus.Status = STATUS_SUCCESS; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_SUCCESS; + } - DPRINT("CCB %p\n", Ccb); - Fcb = Ccb->Fcb; + DPRINT("CCB %p\n", Ccb); + Fcb = Ccb->Fcb; - DPRINT("Cleaning pipe %wZ\n", &Fcb->PipeName); + DPRINT("Cleaning pipe %wZ\n", &Fcb->PipeName); - KeLockMutex(&Fcb->CcbListLock); + KeLockMutex(&Fcb->CcbListLock); - Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END); + Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END); - if (Server) - { - /* FIXME: Clean up existing connections here ?? */ - DPRINT("Server\n"); - } - else - { - DPRINT("Client\n"); - } - if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) - { - OtherSide = Ccb->OtherSide; - /* Lock the server first */ - if (Server) - { - ExAcquireFastMutex(&Ccb->DataListLock); - ExAcquireFastMutex(&OtherSide->DataListLock); - } - else - { - ExAcquireFastMutex(&OtherSide->DataListLock); - ExAcquireFastMutex(&Ccb->DataListLock); - } - OtherSide->PipeState = FILE_PIPE_DISCONNECTED_STATE; - OtherSide->OtherSide = NULL; - /* - * Signaling the write event. If is possible that an other - * thread waits for an empty buffer. - */ - KeSetEvent(&OtherSide->ReadEvent, IO_NO_INCREMENT, FALSE); - KeSetEvent(&OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE); - if (Server) - { - ExReleaseFastMutex(&OtherSide->DataListLock); - ExReleaseFastMutex(&Ccb->DataListLock); - } - else - { - ExReleaseFastMutex(&Ccb->DataListLock); - ExReleaseFastMutex(&OtherSide->DataListLock); - } - } - else if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE) - { - PLIST_ENTRY Entry; - PNPFS_WAITER_ENTRY WaitEntry = NULL; - BOOLEAN Complete = FALSE; - KIRQL oldIrql; - PIRP tmpIrp; + if (Server) + { + /* FIXME: Clean up existing connections here ?? */ + DPRINT("Server\n"); + } + else + { + DPRINT("Client\n"); + } + if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) + { + OtherSide = Ccb->OtherSide; + /* Lock the server first */ + if (Server) + { + ExAcquireFastMutex(&Ccb->DataListLock); + ExAcquireFastMutex(&OtherSide->DataListLock); + } + else + { + ExAcquireFastMutex(&OtherSide->DataListLock); + ExAcquireFastMutex(&Ccb->DataListLock); + } + OtherSide->PipeState = FILE_PIPE_DISCONNECTED_STATE; + OtherSide->OtherSide = NULL; + /* + * Signaling the write event. If is possible that an other + * thread waits for an empty buffer. + */ + KeSetEvent(&OtherSide->ReadEvent, IO_NO_INCREMENT, FALSE); + KeSetEvent(&OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE); + if (Server) + { + ExReleaseFastMutex(&OtherSide->DataListLock); + ExReleaseFastMutex(&Ccb->DataListLock); + } + else + { + ExReleaseFastMutex(&Ccb->DataListLock); + ExReleaseFastMutex(&OtherSide->DataListLock); + } + } + else if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE) + { + PLIST_ENTRY Entry; + PNPFS_WAITER_ENTRY WaitEntry = NULL; + BOOLEAN Complete = FALSE; + KIRQL oldIrql; + PIRP tmpIrp; - Entry = Ccb->Fcb->WaiterListHead.Flink; - while (Entry != &Ccb->Fcb->WaiterListHead) - { - WaitEntry = CONTAINING_RECORD(Entry, NPFS_WAITER_ENTRY, Entry); - if (WaitEntry->Ccb == Ccb) - { - RemoveEntryList(Entry); - tmpIrp = CONTAINING_RECORD(WaitEntry, IRP, Tail.Overlay.DriverContext); - IoAcquireCancelSpinLock(&oldIrql); - if (!tmpIrp->Cancel) - { - (void)IoSetCancelRoutine(tmpIrp, NULL); - Complete = TRUE; - } - IoReleaseCancelSpinLock(oldIrql); - if (Complete) - { - tmpIrp->IoStatus.Status = STATUS_PIPE_BROKEN; - tmpIrp->IoStatus.Information = 0; - IoCompleteRequest(tmpIrp, IO_NO_INCREMENT); - } - break; - } - Entry = Entry->Flink; - } + Entry = Ccb->Fcb->WaiterListHead.Flink; + while (Entry != &Ccb->Fcb->WaiterListHead) + { + WaitEntry = CONTAINING_RECORD(Entry, NPFS_WAITER_ENTRY, Entry); + if (WaitEntry->Ccb == Ccb) + { + RemoveEntryList(Entry); + tmpIrp = CONTAINING_RECORD(WaitEntry, IRP, Tail.Overlay.DriverContext); + IoAcquireCancelSpinLock(&oldIrql); + if (!tmpIrp->Cancel) + { + (void)IoSetCancelRoutine(tmpIrp, NULL); + Complete = TRUE; + } + IoReleaseCancelSpinLock(oldIrql); + if (Complete) + { + tmpIrp->IoStatus.Status = STATUS_PIPE_BROKEN; + tmpIrp->IoStatus.Information = 0; + IoCompleteRequest(tmpIrp, IO_NO_INCREMENT); + } + break; + } + Entry = Entry->Flink; + } - } - Ccb->PipeState = FILE_PIPE_CLOSING_STATE; + } + Ccb->PipeState = FILE_PIPE_CLOSING_STATE; - KeUnlockMutex(&Fcb->CcbListLock); + KeUnlockMutex(&Fcb->CcbListLock); - ExAcquireFastMutex(&Ccb->DataListLock); - if (Ccb->Data) - { - ExFreePool(Ccb->Data); - Ccb->Data = NULL; - Ccb->ReadPtr = NULL; - Ccb->WritePtr = NULL; - } - ExReleaseFastMutex(&Ccb->DataListLock); + ExAcquireFastMutex(&Ccb->DataListLock); + if (Ccb->Data) + { + ExFreePool(Ccb->Data); + Ccb->Data = NULL; + Ccb->ReadPtr = NULL; + Ccb->WritePtr = NULL; + } + ExReleaseFastMutex(&Ccb->DataListLock); - Irp->IoStatus.Status = STATUS_SUCCESS; - Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, IO_NO_INCREMENT); + Irp->IoStatus.Status = STATUS_SUCCESS; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); - DPRINT("Success!\n"); + DPRINT("Success!\n"); - return STATUS_SUCCESS; + return STATUS_SUCCESS; } NTSTATUS STDCALL NpfsClose(PDEVICE_OBJECT DeviceObject, - PIRP Irp) + PIRP Irp) { - PNPFS_DEVICE_EXTENSION DeviceExt; - PIO_STACK_LOCATION IoStack; - PFILE_OBJECT FileObject; - PNPFS_FCB Fcb; - PNPFS_CCB Ccb; - BOOLEAN Server; + PNPFS_DEVICE_EXTENSION DeviceExt; + PIO_STACK_LOCATION IoStack; + PFILE_OBJECT FileObject; + PNPFS_FCB Fcb; + PNPFS_CCB Ccb; + BOOLEAN Server; - DPRINT("NpfsClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp); + DPRINT("NpfsClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp); - IoStack = IoGetCurrentIrpStackLocation(Irp); - DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; - FileObject = IoStack->FileObject; - Ccb = FileObject->FsContext2; + IoStack = IoGetCurrentIrpStackLocation(Irp); + DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; + FileObject = IoStack->FileObject; + Ccb = FileObject->FsContext2; - if (Ccb == NULL) - { - DPRINT("Success!\n"); - Irp->IoStatus.Status = STATUS_SUCCESS; - Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_SUCCESS; - } + if (Ccb == NULL) + { + DPRINT("Success!\n"); + Irp->IoStatus.Status = STATUS_SUCCESS; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_SUCCESS; + } - DPRINT("CCB %x\n", Ccb); - Fcb = Ccb->Fcb; + DPRINT("CCB %x\n", Ccb); + Fcb = Ccb->Fcb; - DPRINT("Closing pipe %wZ\n", &Fcb->PipeName); + DPRINT("Closing pipe %wZ\n", &Fcb->PipeName); - KeLockMutex(&Fcb->CcbListLock); + KeLockMutex(&Fcb->CcbListLock); - Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END); + Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END); - if (Server) - { - DPRINT("Server\n"); - Fcb->CurrentInstances--; - } - else - { - DPRINT("Client\n"); - } + if (Server) + { + DPRINT("Server\n"); + Fcb->CurrentInstances--; + } + else + { + DPRINT("Client\n"); + } - ASSERT(Ccb->PipeState == FILE_PIPE_CLOSING_STATE); + ASSERT(Ccb->PipeState == FILE_PIPE_CLOSING_STATE); - FileObject->FsContext2 = NULL; + FileObject->FsContext2 = NULL; - RemoveEntryList(&Ccb->CcbListEntry); + RemoveEntryList(&Ccb->CcbListEntry); - ExFreePool(Ccb); + ExFreePool(Ccb); - KeUnlockMutex(&Fcb->CcbListLock); + KeUnlockMutex(&Fcb->CcbListLock); - if (IsListEmpty(&Fcb->ServerCcbListHead) && - IsListEmpty(&Fcb->ClientCcbListHead)) - { - RtlFreeUnicodeString(&Fcb->PipeName); - KeLockMutex(&DeviceExt->PipeListLock); - RemoveEntryList(&Fcb->PipeListEntry); - KeUnlockMutex(&DeviceExt->PipeListLock); - ExFreePool(Fcb); - FileObject->FsContext = NULL; - } + if (IsListEmpty(&Fcb->ServerCcbListHead) && + IsListEmpty(&Fcb->ClientCcbListHead)) + { + RtlFreeUnicodeString(&Fcb->PipeName); + KeLockMutex(&DeviceExt->PipeListLock); + RemoveEntryList(&Fcb->PipeListEntry); + KeUnlockMutex(&DeviceExt->PipeListLock); + ExFreePool(Fcb); + FileObject->FsContext = NULL; + } - Irp->IoStatus.Status = STATUS_SUCCESS; - Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, IO_NO_INCREMENT); + Irp->IoStatus.Status = STATUS_SUCCESS; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); - DPRINT("Success!\n"); + DPRINT("Success!\n"); - return STATUS_SUCCESS; + return STATUS_SUCCESS; } /* EOF */ diff --git a/reactos/drivers/filesystems/npfs/finfo.c b/reactos/drivers/filesystems/npfs/finfo.c index e65c17c498a..ef38e242822 100644 --- a/reactos/drivers/filesystems/npfs/finfo.c +++ b/reactos/drivers/filesystems/npfs/finfo.c @@ -1,10 +1,10 @@ /* - * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel - * FILE: drivers/fs/np/finfo.c - * PURPOSE: Named pipe filesystem - * PROGRAMMER: Eric Kohl - */ +* COPYRIGHT: See COPYING in the top level directory +* PROJECT: ReactOS kernel +* FILE: drivers/fs/np/finfo.c +* PURPOSE: Named pipe filesystem +* PROGRAMMER: Eric Kohl +*/ /* INCLUDES ******************************************************************/ @@ -18,268 +18,268 @@ static NTSTATUS NpfsSetPipeInformation(PDEVICE_OBJECT DeviceObject, - PNPFS_CCB Ccb, - PFILE_PIPE_INFORMATION Info, - PULONG BufferLength) + PNPFS_CCB Ccb, + PFILE_PIPE_INFORMATION Info, + PULONG BufferLength) { - PNPFS_FCB Fcb; - PFILE_PIPE_INFORMATION Request; - DPRINT("NpfsSetPipeInformation()\n"); + PNPFS_FCB Fcb; + PFILE_PIPE_INFORMATION Request; + DPRINT("NpfsSetPipeInformation()\n"); - /* Get the Pipe and data */ - Fcb = Ccb->Fcb; - Request = (PFILE_PIPE_INFORMATION)Info; + /* Get the Pipe and data */ + Fcb = Ccb->Fcb; + Request = (PFILE_PIPE_INFORMATION)Info; - /* Set Pipe Data */ - Fcb->ReadMode = Request->ReadMode; - Fcb->CompletionMode = Request->CompletionMode; + /* Set Pipe Data */ + Fcb->ReadMode = Request->ReadMode; + Fcb->CompletionMode = Request->CompletionMode; - /* Return Success */ - return STATUS_SUCCESS; + /* Return Success */ + return STATUS_SUCCESS; } static NTSTATUS NpfsSetPipeRemoteInformation(PDEVICE_OBJECT DeviceObject, - PNPFS_CCB Ccb, - PFILE_PIPE_INFORMATION Info, - PULONG BufferLength) + PNPFS_CCB Ccb, + PFILE_PIPE_INFORMATION Info, + PULONG BufferLength) { - PNPFS_FCB Fcb; - PFILE_PIPE_REMOTE_INFORMATION Request; - DPRINT("NpfsSetPipeRemoteInformation()\n"); + PNPFS_FCB Fcb; + PFILE_PIPE_REMOTE_INFORMATION Request; + DPRINT("NpfsSetPipeRemoteInformation()\n"); - /* Get the Pipe and data */ - Fcb = Ccb->Fcb; - Request = (PFILE_PIPE_REMOTE_INFORMATION)Info; + /* Get the Pipe and data */ + Fcb = Ccb->Fcb; + Request = (PFILE_PIPE_REMOTE_INFORMATION)Info; - /* Set the Settings */ - Fcb->TimeOut = Request->CollectDataTime; - Fcb->InboundQuota = Request->MaximumCollectionCount; + /* Set the Settings */ + Fcb->TimeOut = Request->CollectDataTime; + Fcb->InboundQuota = Request->MaximumCollectionCount; - /* Return Success */ - return STATUS_SUCCESS; + /* Return Success */ + return STATUS_SUCCESS; } static NTSTATUS NpfsQueryPipeInformation(PDEVICE_OBJECT DeviceObject, - PNPFS_CCB Ccb, - PFILE_PIPE_INFORMATION Info, - PULONG BufferLength) + PNPFS_CCB Ccb, + PFILE_PIPE_INFORMATION Info, + PULONG BufferLength) { - PNPFS_FCB Fcb; - DPRINT("NpfsQueryPipeInformation()\n"); + PNPFS_FCB Fcb; + DPRINT("NpfsQueryPipeInformation()\n"); - /* Get the Pipe */ - Fcb = Ccb->Fcb; + /* Get the Pipe */ + Fcb = Ccb->Fcb; - /* Clear Info */ - RtlZeroMemory(Info, sizeof(FILE_PIPE_INFORMATION)); + /* Clear Info */ + RtlZeroMemory(Info, sizeof(FILE_PIPE_INFORMATION)); - /* Return Info */ - Info->CompletionMode = Fcb->CompletionMode; - Info->ReadMode = Fcb->ReadMode; + /* Return Info */ + Info->CompletionMode = Fcb->CompletionMode; + Info->ReadMode = Fcb->ReadMode; - /* Return success */ - *BufferLength -= sizeof(FILE_PIPE_INFORMATION); - return STATUS_SUCCESS; + /* Return success */ + *BufferLength -= sizeof(FILE_PIPE_INFORMATION); + return STATUS_SUCCESS; } static NTSTATUS NpfsQueryPipeRemoteInformation(PDEVICE_OBJECT DeviceObject, - PNPFS_CCB Ccb, - PFILE_PIPE_REMOTE_INFORMATION Info, - PULONG BufferLength) + PNPFS_CCB Ccb, + PFILE_PIPE_REMOTE_INFORMATION Info, + PULONG BufferLength) { - PNPFS_FCB Fcb; - DPRINT("NpfsQueryPipeRemoteInformation()\n"); + PNPFS_FCB Fcb; + DPRINT("NpfsQueryPipeRemoteInformation()\n"); - /* Get the Pipe */ - Fcb = Ccb->Fcb; + /* Get the Pipe */ + Fcb = Ccb->Fcb; - /* Clear Info */ - RtlZeroMemory(Info, sizeof(FILE_PIPE_REMOTE_INFORMATION)); + /* Clear Info */ + RtlZeroMemory(Info, sizeof(FILE_PIPE_REMOTE_INFORMATION)); - /* Return Info */ - Info->MaximumCollectionCount = Fcb->InboundQuota; - Info->CollectDataTime = Fcb->TimeOut; + /* Return Info */ + Info->MaximumCollectionCount = Fcb->InboundQuota; + Info->CollectDataTime = Fcb->TimeOut; - /* Return success */ - *BufferLength -= sizeof(FILE_PIPE_REMOTE_INFORMATION); - return STATUS_SUCCESS; + /* Return success */ + *BufferLength -= sizeof(FILE_PIPE_REMOTE_INFORMATION); + return STATUS_SUCCESS; } static NTSTATUS NpfsQueryLocalPipeInformation(PDEVICE_OBJECT DeviceObject, - PNPFS_CCB Ccb, - PFILE_PIPE_LOCAL_INFORMATION Info, - PULONG BufferLength) + PNPFS_CCB Ccb, + PFILE_PIPE_LOCAL_INFORMATION Info, + PULONG BufferLength) { - PNPFS_FCB Fcb; + PNPFS_FCB Fcb; - DPRINT("NpfsQueryLocalPipeInformation()\n"); + DPRINT("NpfsQueryLocalPipeInformation()\n"); - Fcb = Ccb->Fcb; + Fcb = Ccb->Fcb; - RtlZeroMemory(Info, + RtlZeroMemory(Info, sizeof(FILE_PIPE_LOCAL_INFORMATION)); - Info->NamedPipeType = Fcb->PipeType; - Info->NamedPipeConfiguration = Fcb->PipeConfiguration; - Info->MaximumInstances = Fcb->MaximumInstances; - Info->CurrentInstances = Fcb->CurrentInstances; - Info->InboundQuota = Fcb->InboundQuota; - Info->OutboundQuota = Fcb->OutboundQuota; - Info->NamedPipeState = Ccb->PipeState; - Info->NamedPipeEnd = Ccb->PipeEnd; + Info->NamedPipeType = Fcb->PipeType; + Info->NamedPipeConfiguration = Fcb->PipeConfiguration; + Info->MaximumInstances = Fcb->MaximumInstances; + Info->CurrentInstances = Fcb->CurrentInstances; + Info->InboundQuota = Fcb->InboundQuota; + Info->OutboundQuota = Fcb->OutboundQuota; + Info->NamedPipeState = Ccb->PipeState; + Info->NamedPipeEnd = Ccb->PipeEnd; - if (Ccb->PipeEnd == FILE_PIPE_SERVER_END) - { - Info->ReadDataAvailable = Ccb->ReadDataAvailable; - Info->WriteQuotaAvailable = Ccb->WriteQuotaAvailable; - } - else if (Ccb->OtherSide != NULL) - { - Info->ReadDataAvailable = Ccb->OtherSide->ReadDataAvailable; - Info->WriteQuotaAvailable = Ccb->OtherSide->WriteQuotaAvailable; - } + if (Ccb->PipeEnd == FILE_PIPE_SERVER_END) + { + Info->ReadDataAvailable = Ccb->ReadDataAvailable; + Info->WriteQuotaAvailable = Ccb->WriteQuotaAvailable; + } + else if (Ccb->OtherSide != NULL) + { + Info->ReadDataAvailable = Ccb->OtherSide->ReadDataAvailable; + Info->WriteQuotaAvailable = Ccb->OtherSide->WriteQuotaAvailable; + } - *BufferLength -= sizeof(FILE_PIPE_LOCAL_INFORMATION); - return STATUS_SUCCESS; + *BufferLength -= sizeof(FILE_PIPE_LOCAL_INFORMATION); + return STATUS_SUCCESS; } NTSTATUS STDCALL NpfsQueryInformation(PDEVICE_OBJECT DeviceObject, - PIRP Irp) + PIRP Irp) { - PIO_STACK_LOCATION IoStack; - FILE_INFORMATION_CLASS FileInformationClass; - PFILE_OBJECT FileObject; - PNPFS_DEVICE_EXTENSION DeviceExtension; - PNPFS_FCB Fcb; - PNPFS_CCB Ccb; - PVOID SystemBuffer; - ULONG BufferLength; - NTSTATUS Status; + PIO_STACK_LOCATION IoStack; + FILE_INFORMATION_CLASS FileInformationClass; + PFILE_OBJECT FileObject; + PNPFS_DEVICE_EXTENSION DeviceExtension; + PNPFS_FCB Fcb; + PNPFS_CCB Ccb; + PVOID SystemBuffer; + ULONG BufferLength; + NTSTATUS Status; - DPRINT("NpfsQueryInformation(DeviceObject %p Irp %p)\n", DeviceObject, Irp); + DPRINT("NpfsQueryInformation(DeviceObject %p Irp %p)\n", DeviceObject, Irp); - IoStack = IoGetCurrentIrpStackLocation (Irp); - FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass; - DeviceExtension = DeviceObject->DeviceExtension; - FileObject = IoStack->FileObject; - Ccb = (PNPFS_CCB)FileObject->FsContext2; - Fcb = Ccb->Fcb; + IoStack = IoGetCurrentIrpStackLocation (Irp); + FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass; + DeviceExtension = DeviceObject->DeviceExtension; + FileObject = IoStack->FileObject; + Ccb = (PNPFS_CCB)FileObject->FsContext2; + Fcb = Ccb->Fcb; - SystemBuffer = Irp->AssociatedIrp.SystemBuffer; - BufferLength = IoStack->Parameters.QueryFile.Length; + SystemBuffer = Irp->AssociatedIrp.SystemBuffer; + BufferLength = IoStack->Parameters.QueryFile.Length; - DPRINT("Pipe name: %wZ\n", &Fcb->PipeName); - DPRINT("FileInformationClass %d\n", FileInformationClass); - DPRINT("SystemBuffer %p\n", SystemBuffer); - DPRINT("BufferLength %lu\n", BufferLength); + DPRINT("Pipe name: %wZ\n", &Fcb->PipeName); + DPRINT("FileInformationClass %d\n", FileInformationClass); + DPRINT("SystemBuffer %p\n", SystemBuffer); + DPRINT("BufferLength %lu\n", BufferLength); - switch (FileInformationClass) - { - case FilePipeInformation: - Status = NpfsQueryPipeInformation(DeviceObject, - Ccb, - SystemBuffer, - &BufferLength); - break; + switch (FileInformationClass) + { + case FilePipeInformation: + Status = NpfsQueryPipeInformation(DeviceObject, + Ccb, + SystemBuffer, + &BufferLength); + break; - case FilePipeLocalInformation: - Status = NpfsQueryLocalPipeInformation(DeviceObject, - Ccb, - SystemBuffer, - &BufferLength); - break; + case FilePipeLocalInformation: + Status = NpfsQueryLocalPipeInformation(DeviceObject, + Ccb, + SystemBuffer, + &BufferLength); + break; - case FilePipeRemoteInformation: - Status = NpfsQueryPipeRemoteInformation(DeviceObject, - Ccb, - SystemBuffer, - &BufferLength); - break; + case FilePipeRemoteInformation: + Status = NpfsQueryPipeRemoteInformation(DeviceObject, + Ccb, + SystemBuffer, + &BufferLength); + break; - default: - Status = STATUS_NOT_SUPPORTED; - } + default: + Status = STATUS_NOT_SUPPORTED; + } - 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); + 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; + return Status; } NTSTATUS STDCALL NpfsSetInformation(PDEVICE_OBJECT DeviceObject, - PIRP Irp) + PIRP Irp) { - PIO_STACK_LOCATION IoStack; - FILE_INFORMATION_CLASS FileInformationClass; - PFILE_OBJECT FileObject; - PNPFS_FCB Fcb; - PNPFS_CCB Ccb; - PVOID SystemBuffer; - ULONG BufferLength; - NTSTATUS Status; + PIO_STACK_LOCATION IoStack; + FILE_INFORMATION_CLASS FileInformationClass; + PFILE_OBJECT FileObject; + PNPFS_FCB Fcb; + PNPFS_CCB Ccb; + PVOID SystemBuffer; + ULONG BufferLength; + NTSTATUS Status; - DPRINT("NpfsSetInformation(DeviceObject %p Irp %p)\n", DeviceObject, Irp); + DPRINT("NpfsSetInformation(DeviceObject %p Irp %p)\n", DeviceObject, Irp); - IoStack = IoGetCurrentIrpStackLocation (Irp); - FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass; - FileObject = IoStack->FileObject; - Ccb = (PNPFS_CCB)FileObject->FsContext2; - Fcb = Ccb->Fcb; + IoStack = IoGetCurrentIrpStackLocation (Irp); + FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass; + FileObject = IoStack->FileObject; + Ccb = (PNPFS_CCB)FileObject->FsContext2; + Fcb = Ccb->Fcb; - SystemBuffer = Irp->AssociatedIrp.SystemBuffer; - BufferLength = IoStack->Parameters.QueryFile.Length; + SystemBuffer = Irp->AssociatedIrp.SystemBuffer; + BufferLength = IoStack->Parameters.QueryFile.Length; - DPRINT("Pipe name: %wZ\n", &Fcb->PipeName); - DPRINT("FileInformationClass %d\n", FileInformationClass); - DPRINT("SystemBuffer %p\n", SystemBuffer); - DPRINT("BufferLength %lu\n", BufferLength); + DPRINT("Pipe name: %wZ\n", &Fcb->PipeName); + DPRINT("FileInformationClass %d\n", FileInformationClass); + DPRINT("SystemBuffer %p\n", SystemBuffer); + DPRINT("BufferLength %lu\n", BufferLength); - switch (FileInformationClass) - { - case FilePipeInformation: - /* Call the handler */ - Status = NpfsSetPipeInformation(DeviceObject, - Ccb, - SystemBuffer, - &BufferLength); - break; + switch (FileInformationClass) + { + case FilePipeInformation: + /* Call the handler */ + Status = NpfsSetPipeInformation(DeviceObject, + Ccb, + SystemBuffer, + &BufferLength); + break; - case FilePipeLocalInformation: - Status = STATUS_NOT_IMPLEMENTED; - break; + case FilePipeLocalInformation: + Status = STATUS_NOT_IMPLEMENTED; + break; - case FilePipeRemoteInformation: - /* Call the handler */ - Status = NpfsSetPipeRemoteInformation(DeviceObject, - Ccb, - SystemBuffer, - &BufferLength); - break; - default: - Status = STATUS_NOT_SUPPORTED; - } + case FilePipeRemoteInformation: + /* Call the handler */ + Status = NpfsSetPipeRemoteInformation(DeviceObject, + Ccb, + SystemBuffer, + &BufferLength); + break; + default: + Status = STATUS_NOT_SUPPORTED; + } - Irp->IoStatus.Status = Status; - Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - return Status; + Irp->IoStatus.Status = Status; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return Status; } /* EOF */ diff --git a/reactos/drivers/filesystems/npfs/fsctrl.c b/reactos/drivers/filesystems/npfs/fsctrl.c index f6f52312e16..e450dbebadd 100644 --- a/reactos/drivers/filesystems/npfs/fsctrl.c +++ b/reactos/drivers/filesystems/npfs/fsctrl.c @@ -1,11 +1,11 @@ /* - * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel - * FILE: drivers/fs/np/fsctrl.c - * PURPOSE: Named pipe filesystem - * PROGRAMMER: David Welch - * Eric Kohl - */ +* COPYRIGHT: See COPYING in the top level directory +* PROJECT: ReactOS kernel +* FILE: drivers/fs/np/fsctrl.c +* PURPOSE: Named pipe filesystem +* PROGRAMMER: David Welch +* Eric Kohl +*/ /* INCLUDES ******************************************************************/ @@ -18,513 +18,513 @@ static VOID STDCALL NpfsListeningCancelRoutine(IN PDEVICE_OBJECT DeviceObject, - IN PIRP Irp) + IN PIRP Irp) { - PNPFS_WAITER_ENTRY Waiter; + PNPFS_WAITER_ENTRY Waiter; - Waiter = (PNPFS_WAITER_ENTRY)&Irp->Tail.Overlay.DriverContext; + Waiter = (PNPFS_WAITER_ENTRY)&Irp->Tail.Overlay.DriverContext; - DPRINT("NpfsListeningCancelRoutine() called for <%wZ>\n", - &Waiter->Ccb->Fcb->PipeName); + DPRINT("NpfsListeningCancelRoutine() called for <%wZ>\n", + &Waiter->Ccb->Fcb->PipeName); - IoReleaseCancelSpinLock(Irp->CancelIrql); + IoReleaseCancelSpinLock(Irp->CancelIrql); - KeLockMutex(&Waiter->Ccb->Fcb->CcbListLock); - RemoveEntryList(&Waiter->Entry); - KeUnlockMutex(&Waiter->Ccb->Fcb->CcbListLock); + KeLockMutex(&Waiter->Ccb->Fcb->CcbListLock); + RemoveEntryList(&Waiter->Entry); + KeUnlockMutex(&Waiter->Ccb->Fcb->CcbListLock); - Irp->IoStatus.Status = STATUS_CANCELLED; - Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, IO_NO_INCREMENT); + Irp->IoStatus.Status = STATUS_CANCELLED; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); } static NTSTATUS NpfsAddListeningServerInstance(PIRP Irp, - PNPFS_CCB Ccb) + PNPFS_CCB Ccb) { - PNPFS_WAITER_ENTRY Entry; - KIRQL oldIrql; + PNPFS_WAITER_ENTRY Entry; + KIRQL oldIrql; - Entry = (PNPFS_WAITER_ENTRY)&Irp->Tail.Overlay.DriverContext; + Entry = (PNPFS_WAITER_ENTRY)&Irp->Tail.Overlay.DriverContext; - Entry->Ccb = Ccb; + Entry->Ccb = Ccb; - KeLockMutex(&Ccb->Fcb->CcbListLock); + KeLockMutex(&Ccb->Fcb->CcbListLock); - IoMarkIrpPending(Irp); - InsertTailList(&Ccb->Fcb->WaiterListHead, &Entry->Entry); + IoMarkIrpPending(Irp); + InsertTailList(&Ccb->Fcb->WaiterListHead, &Entry->Entry); - IoAcquireCancelSpinLock(&oldIrql); - if (!Irp->Cancel) - { - (void)IoSetCancelRoutine(Irp, NpfsListeningCancelRoutine); - IoReleaseCancelSpinLock(oldIrql); - KeUnlockMutex(&Ccb->Fcb->CcbListLock); - return STATUS_PENDING; - } - IoReleaseCancelSpinLock(oldIrql); + IoAcquireCancelSpinLock(&oldIrql); + if (!Irp->Cancel) + { + (void)IoSetCancelRoutine(Irp, NpfsListeningCancelRoutine); + IoReleaseCancelSpinLock(oldIrql); + KeUnlockMutex(&Ccb->Fcb->CcbListLock); + return STATUS_PENDING; + } + IoReleaseCancelSpinLock(oldIrql); - RemoveEntryList(&Entry->Entry); + RemoveEntryList(&Entry->Entry); - Irp->IoStatus.Status = STATUS_CANCELLED; - Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - KeUnlockMutex(&Ccb->Fcb->CcbListLock); + Irp->IoStatus.Status = STATUS_CANCELLED; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + KeUnlockMutex(&Ccb->Fcb->CcbListLock); - return STATUS_CANCELLED; + return STATUS_CANCELLED; } static NTSTATUS NpfsConnectPipe(PIRP Irp, - PNPFS_CCB Ccb) + PNPFS_CCB Ccb) { - PIO_STACK_LOCATION IoStack; - PFILE_OBJECT FileObject; - ULONG Flags; - PLIST_ENTRY current_entry; - PNPFS_FCB Fcb; - PNPFS_CCB ClientCcb; - NTSTATUS Status; + PIO_STACK_LOCATION IoStack; + PFILE_OBJECT FileObject; + ULONG Flags; + PLIST_ENTRY current_entry; + PNPFS_FCB Fcb; + PNPFS_CCB ClientCcb; + NTSTATUS Status; - DPRINT("NpfsConnectPipe()\n"); + DPRINT("NpfsConnectPipe()\n"); - if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) - { - KeResetEvent(&Ccb->ConnectEvent); - return STATUS_PIPE_CONNECTED; - } - - if (Ccb->PipeState == FILE_PIPE_CLOSING_STATE) - return STATUS_PIPE_CLOSING; - - DPRINT("Waiting for connection...\n"); - - Fcb = Ccb->Fcb; - IoStack = IoGetCurrentIrpStackLocation(Irp); - FileObject = IoStack->FileObject; - Flags = FileObject->Flags; - - /* search for a listening client fcb */ - KeLockMutex(&Fcb->CcbListLock); - - current_entry = Fcb->ClientCcbListHead.Flink; - while (current_entry != &Fcb->ClientCcbListHead) - { - ClientCcb = CONTAINING_RECORD(current_entry, - NPFS_CCB, - CcbListEntry); - - if (ClientCcb->PipeState == 0) + if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) { - /* found a passive (waiting) client CCB */ - DPRINT("Passive (waiting) client CCB found -- wake the client\n"); - KeSetEvent(&ClientCcb->ConnectEvent, IO_NO_INCREMENT, FALSE); - break; + KeResetEvent(&Ccb->ConnectEvent); + return STATUS_PIPE_CONNECTED; } + if (Ccb->PipeState == FILE_PIPE_CLOSING_STATE) + return STATUS_PIPE_CLOSING; + + DPRINT("Waiting for connection...\n"); + + Fcb = Ccb->Fcb; + IoStack = IoGetCurrentIrpStackLocation(Irp); + FileObject = IoStack->FileObject; + Flags = FileObject->Flags; + + /* search for a listening client fcb */ + KeLockMutex(&Fcb->CcbListLock); + + current_entry = Fcb->ClientCcbListHead.Flink; + while (current_entry != &Fcb->ClientCcbListHead) + { + ClientCcb = CONTAINING_RECORD(current_entry, + NPFS_CCB, + CcbListEntry); + + if (ClientCcb->PipeState == 0) + { + /* found a passive (waiting) client CCB */ + DPRINT("Passive (waiting) client CCB found -- wake the client\n"); + KeSetEvent(&ClientCcb->ConnectEvent, IO_NO_INCREMENT, FALSE); + break; + } + #if 0 - if (ClientCcb->PipeState == FILE_PIPE_LISTENING_STATE) - { - /* found a listening client CCB */ - DPRINT("Listening client CCB found -- connecting\n"); + if (ClientCcb->PipeState == FILE_PIPE_LISTENING_STATE) + { + /* found a listening client CCB */ + DPRINT("Listening client CCB found -- connecting\n"); - /* connect client and server CCBs */ - Ccb->OtherSide = ClientCcb; - ClientCcb->OtherSide = Ccb; + /* connect client and server CCBs */ + Ccb->OtherSide = ClientCcb; + ClientCcb->OtherSide = Ccb; - /* set connected state */ - Ccb->PipeState = FILE_PIPE_CONNECTED_STATE; - ClientCcb->PipeState = FILE_PIPE_CONNECTED_STATE; + /* set connected state */ + Ccb->PipeState = FILE_PIPE_CONNECTED_STATE; + ClientCcb->PipeState = FILE_PIPE_CONNECTED_STATE; - KeUnlockMutex(&Fcb->CcbListLock); + KeUnlockMutex(&Fcb->CcbListLock); - /* FIXME: create and initialize data queues */ + /* FIXME: create and initialize data queues */ - /* signal client's connect event */ - DPRINT("Setting the ConnectEvent for %x\n", ClientCcb); - KeSetEvent(&ClientCcb->ConnectEvent, IO_NO_INCREMENT, FALSE); + /* signal client's connect event */ + DPRINT("Setting the ConnectEvent for %x\n", ClientCcb); + KeSetEvent(&ClientCcb->ConnectEvent, IO_NO_INCREMENT, FALSE); - return STATUS_PIPE_CONNECTED; - } + return STATUS_PIPE_CONNECTED; + } #endif - current_entry = current_entry->Flink; - } + current_entry = current_entry->Flink; + } - /* no listening client fcb found */ - DPRINT("No listening client fcb found -- waiting for client\n"); + /* no listening client fcb found */ + DPRINT("No listening client fcb found -- waiting for client\n"); - Ccb->PipeState = FILE_PIPE_LISTENING_STATE; + Ccb->PipeState = FILE_PIPE_LISTENING_STATE; - Status = NpfsAddListeningServerInstance(Irp, Ccb); + Status = NpfsAddListeningServerInstance(Irp, Ccb); - KeUnlockMutex(&Fcb->CcbListLock); + KeUnlockMutex(&Fcb->CcbListLock); - if (Flags & FO_SYNCHRONOUS_IO) - { - KeWaitForSingleObject(&Ccb->ConnectEvent, - UserRequest, - KernelMode, - FALSE, - NULL); - } + if (Flags & FO_SYNCHRONOUS_IO) + { + KeWaitForSingleObject(&Ccb->ConnectEvent, + UserRequest, + KernelMode, + FALSE, + NULL); + } - DPRINT("NpfsConnectPipe() done (Status %lx)\n", Status); + DPRINT("NpfsConnectPipe() done (Status %lx)\n", Status); - return Status; + return Status; } static NTSTATUS NpfsDisconnectPipe(PNPFS_CCB Ccb) { - NTSTATUS Status; - PNPFS_FCB Fcb; - PNPFS_CCB OtherSide; - BOOLEAN Server; + NTSTATUS Status; + PNPFS_FCB Fcb; + PNPFS_CCB OtherSide; + BOOLEAN Server; - DPRINT("NpfsDisconnectPipe()\n"); + DPRINT("NpfsDisconnectPipe()\n"); - Fcb = Ccb->Fcb; - KeLockMutex(&Fcb->CcbListLock); + Fcb = Ccb->Fcb; + KeLockMutex(&Fcb->CcbListLock); - if (Ccb->PipeState == FILE_PIPE_DISCONNECTED_STATE) - { - DPRINT("Pipe is already disconnected\n"); - Status = STATUS_SUCCESS; - } - else if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) - { - Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END); - OtherSide = Ccb->OtherSide; - Ccb->OtherSide = NULL; - Ccb->PipeState = FILE_PIPE_DISCONNECTED_STATE; - /* Lock the server first */ - if (Server) - { - ExAcquireFastMutex(&Ccb->DataListLock); - ExAcquireFastMutex(&OtherSide->DataListLock); - } - else - { - ExAcquireFastMutex(&OtherSide->DataListLock); - ExAcquireFastMutex(&Ccb->DataListLock); - } - OtherSide->PipeState = FILE_PIPE_DISCONNECTED_STATE; - OtherSide->OtherSide = NULL; - /* - * Signaling the write event. If is possible that an other - * thread waits for an empty buffer. - */ - KeSetEvent(&OtherSide->ReadEvent, IO_NO_INCREMENT, FALSE); - KeSetEvent(&OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE); - if (Server) - { - ExReleaseFastMutex(&OtherSide->DataListLock); - ExReleaseFastMutex(&Ccb->DataListLock); - } - else - { - ExReleaseFastMutex(&Ccb->DataListLock); - ExReleaseFastMutex(&OtherSide->DataListLock); - } - Status = STATUS_SUCCESS; - } - else if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE) - { - PLIST_ENTRY Entry; - PNPFS_WAITER_ENTRY WaitEntry = NULL; - BOOLEAN Complete = FALSE; - PIRP Irp = NULL; + if (Ccb->PipeState == FILE_PIPE_DISCONNECTED_STATE) + { + DPRINT("Pipe is already disconnected\n"); + Status = STATUS_SUCCESS; + } + else if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) + { + Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END); + OtherSide = Ccb->OtherSide; + Ccb->OtherSide = NULL; + Ccb->PipeState = FILE_PIPE_DISCONNECTED_STATE; + /* Lock the server first */ + if (Server) + { + ExAcquireFastMutex(&Ccb->DataListLock); + ExAcquireFastMutex(&OtherSide->DataListLock); + } + else + { + ExAcquireFastMutex(&OtherSide->DataListLock); + ExAcquireFastMutex(&Ccb->DataListLock); + } + OtherSide->PipeState = FILE_PIPE_DISCONNECTED_STATE; + OtherSide->OtherSide = NULL; + /* + * Signaling the write event. If is possible that an other + * thread waits for an empty buffer. + */ + KeSetEvent(&OtherSide->ReadEvent, IO_NO_INCREMENT, FALSE); + KeSetEvent(&OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE); + if (Server) + { + ExReleaseFastMutex(&OtherSide->DataListLock); + ExReleaseFastMutex(&Ccb->DataListLock); + } + else + { + ExReleaseFastMutex(&Ccb->DataListLock); + ExReleaseFastMutex(&OtherSide->DataListLock); + } + Status = STATUS_SUCCESS; + } + else if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE) + { + PLIST_ENTRY Entry; + PNPFS_WAITER_ENTRY WaitEntry = NULL; + BOOLEAN Complete = FALSE; + PIRP Irp = NULL; - Entry = Ccb->Fcb->WaiterListHead.Flink; - while (Entry != &Ccb->Fcb->WaiterListHead) - { - WaitEntry = CONTAINING_RECORD(Entry, NPFS_WAITER_ENTRY, Entry); - if (WaitEntry->Ccb == Ccb) - { - RemoveEntryList(Entry); - Irp = CONTAINING_RECORD(Entry, IRP, Tail.Overlay.DriverContext); - Complete = (NULL == IoSetCancelRoutine(Irp, NULL)); - break; - } - Entry = Entry->Flink; - } + Entry = Ccb->Fcb->WaiterListHead.Flink; + while (Entry != &Ccb->Fcb->WaiterListHead) + { + WaitEntry = CONTAINING_RECORD(Entry, NPFS_WAITER_ENTRY, Entry); + if (WaitEntry->Ccb == Ccb) + { + RemoveEntryList(Entry); + Irp = CONTAINING_RECORD(Entry, IRP, Tail.Overlay.DriverContext); + Complete = (NULL == IoSetCancelRoutine(Irp, NULL)); + break; + } + Entry = Entry->Flink; + } - if (Irp) - { - if (Complete) - { - Irp->IoStatus.Status = STATUS_PIPE_BROKEN; - Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - } - } - Ccb->PipeState = FILE_PIPE_DISCONNECTED_STATE; - Status = STATUS_SUCCESS; - } - else if (Ccb->PipeState == FILE_PIPE_CLOSING_STATE) - { - Status = STATUS_PIPE_CLOSING; - } - else - { - Status = STATUS_UNSUCCESSFUL; - } - KeUnlockMutex(&Fcb->CcbListLock); - return Status; + if (Irp) + { + if (Complete) + { + Irp->IoStatus.Status = STATUS_PIPE_BROKEN; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + } + } + Ccb->PipeState = FILE_PIPE_DISCONNECTED_STATE; + Status = STATUS_SUCCESS; + } + else if (Ccb->PipeState == FILE_PIPE_CLOSING_STATE) + { + Status = STATUS_PIPE_CLOSING; + } + else + { + Status = STATUS_UNSUCCESSFUL; + } + KeUnlockMutex(&Fcb->CcbListLock); + return Status; } static NTSTATUS NpfsWaitPipe(PIRP Irp, - PNPFS_CCB Ccb) + PNPFS_CCB Ccb) { - PLIST_ENTRY current_entry; - PNPFS_FCB Fcb; - PNPFS_CCB ServerCcb; - PFILE_PIPE_WAIT_FOR_BUFFER WaitPipe; - NTSTATUS Status; + PLIST_ENTRY current_entry; + PNPFS_FCB Fcb; + PNPFS_CCB ServerCcb; + PFILE_PIPE_WAIT_FOR_BUFFER WaitPipe; + NTSTATUS Status; - DPRINT("NpfsWaitPipe\n"); + DPRINT("NpfsWaitPipe\n"); - WaitPipe = (PFILE_PIPE_WAIT_FOR_BUFFER)Irp->AssociatedIrp.SystemBuffer; - Fcb = Ccb->Fcb; + WaitPipe = (PFILE_PIPE_WAIT_FOR_BUFFER)Irp->AssociatedIrp.SystemBuffer; + Fcb = Ccb->Fcb; - if (Ccb->PipeState != 0) - { - DPRINT("Pipe is not in passive (waiting) state!\n"); - return STATUS_UNSUCCESSFUL; - } - - /* search for listening server */ - current_entry = Fcb->ServerCcbListHead.Flink; - while (current_entry != &Fcb->ServerCcbListHead) - { - ServerCcb = CONTAINING_RECORD(current_entry, - NPFS_CCB, - CcbListEntry); - - if (ServerCcb->PipeState == FILE_PIPE_LISTENING_STATE) + if (Ccb->PipeState != 0) { - /* found a listening server CCB */ - DPRINT("Listening server CCB found -- connecting\n"); - - return STATUS_SUCCESS; + DPRINT("Pipe is not in passive (waiting) state!\n"); + return STATUS_UNSUCCESSFUL; } - current_entry = current_entry->Flink; - } + /* search for listening server */ + current_entry = Fcb->ServerCcbListHead.Flink; + while (current_entry != &Fcb->ServerCcbListHead) + { + ServerCcb = CONTAINING_RECORD(current_entry, + NPFS_CCB, + CcbListEntry); - /* no listening server fcb found -- wait for one */ - Status = KeWaitForSingleObject(&Ccb->ConnectEvent, - UserRequest, - KernelMode, - FALSE, - &WaitPipe->Timeout); + if (ServerCcb->PipeState == FILE_PIPE_LISTENING_STATE) + { + /* found a listening server CCB */ + DPRINT("Listening server CCB found -- connecting\n"); - DPRINT("KeWaitForSingleObject() returned (Status %lx)\n", Status); + return STATUS_SUCCESS; + } - return Status; + current_entry = current_entry->Flink; + } + + /* no listening server fcb found -- wait for one */ + Status = KeWaitForSingleObject(&Ccb->ConnectEvent, + UserRequest, + KernelMode, + FALSE, + &WaitPipe->Timeout); + + DPRINT("KeWaitForSingleObject() returned (Status %lx)\n", Status); + + return Status; } /* - * FUNCTION: Return current state of a pipe - * ARGUMENTS: - * Irp = Pointer to I/O request packet - * IrpSp = Pointer to current stack location of Irp - * RETURNS: - * Status of operation - */ +* FUNCTION: Return current state of a pipe +* ARGUMENTS: +* Irp = Pointer to I/O request packet +* IrpSp = Pointer to current stack location of Irp +* RETURNS: +* Status of operation +*/ /* - * FUNCTION: Peek at a pipe (get information about messages) - * ARGUMENTS: - * Irp = Pointer to I/O request packet - * IoStack = Pointer to current stack location of Irp - * RETURNS: - * Status of operation - */ +* FUNCTION: Peek at a pipe (get information about messages) +* ARGUMENTS: +* Irp = Pointer to I/O request packet +* IoStack = Pointer to current stack location of Irp +* RETURNS: +* Status of operation +*/ static NTSTATUS NpfsPeekPipe(PIRP Irp, - PIO_STACK_LOCATION IoStack) + PIO_STACK_LOCATION IoStack) { - ULONG OutputBufferLength; - PFILE_PIPE_PEEK_BUFFER Reply; - PNPFS_FCB Fcb; - PNPFS_CCB Ccb; - NTSTATUS Status; + ULONG OutputBufferLength; + PFILE_PIPE_PEEK_BUFFER Reply; + PNPFS_FCB Fcb; + PNPFS_CCB Ccb; + NTSTATUS Status; - DPRINT1("NpfsPeekPipe\n"); + DPRINT1("NpfsPeekPipe\n"); - OutputBufferLength = IoStack->Parameters.DeviceIoControl.OutputBufferLength; - DPRINT1("OutputBufferLength: %lu\n", OutputBufferLength); + OutputBufferLength = IoStack->Parameters.DeviceIoControl.OutputBufferLength; + DPRINT1("OutputBufferLength: %lu\n", OutputBufferLength); - /* Validate parameters */ - if (OutputBufferLength < sizeof(FILE_PIPE_PEEK_BUFFER)) - { - DPRINT1("Buffer too small\n"); - return STATUS_INVALID_PARAMETER; - } + /* Validate parameters */ + if (OutputBufferLength < sizeof(FILE_PIPE_PEEK_BUFFER)) + { + DPRINT1("Buffer too small\n"); + return STATUS_INVALID_PARAMETER; + } - Ccb = IoStack->FileObject->FsContext2; - Reply = (PFILE_PIPE_PEEK_BUFFER)Irp->AssociatedIrp.SystemBuffer; - Fcb = Ccb->Fcb; + Ccb = IoStack->FileObject->FsContext2; + Reply = (PFILE_PIPE_PEEK_BUFFER)Irp->AssociatedIrp.SystemBuffer; + Fcb = Ccb->Fcb; - Reply->NamedPipeState = Ccb->PipeState; + Reply->NamedPipeState = Ccb->PipeState; - Reply->ReadDataAvailable = Ccb->ReadDataAvailable; - DPRINT("ReadDataAvailable: %lu\n", Ccb->ReadDataAvailable); + Reply->ReadDataAvailable = Ccb->ReadDataAvailable; + DPRINT("ReadDataAvailable: %lu\n", Ccb->ReadDataAvailable); - Reply->NumberOfMessages = 0; /* FIXME */ - Reply->MessageLength = 0; /* FIXME */ - Reply->Data[0] = 0; /* FIXME */ + Reply->NumberOfMessages = 0; /* FIXME */ + Reply->MessageLength = 0; /* FIXME */ + Reply->Data[0] = 0; /* FIXME */ -// Irp->IoStatus.Information = sizeof(FILE_PIPE_PEEK_BUFFER); + // Irp->IoStatus.Information = sizeof(FILE_PIPE_PEEK_BUFFER); -// Status = STATUS_SUCCESS; - Status = STATUS_NOT_IMPLEMENTED; + // Status = STATUS_SUCCESS; + Status = STATUS_NOT_IMPLEMENTED; - DPRINT1("NpfsPeekPipe done\n"); + DPRINT1("NpfsPeekPipe done\n"); - return Status; + return Status; } NTSTATUS STDCALL NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject, - PIRP Irp) + PIRP Irp) { - PIO_STACK_LOCATION IoStack; - PFILE_OBJECT FileObject; - NTSTATUS Status; - PNPFS_DEVICE_EXTENSION DeviceExt; - PNPFS_FCB Fcb; - PNPFS_CCB Ccb; + PIO_STACK_LOCATION IoStack; + PFILE_OBJECT FileObject; + NTSTATUS Status; + PNPFS_DEVICE_EXTENSION DeviceExt; + PNPFS_FCB Fcb; + PNPFS_CCB Ccb; - DPRINT("NpfsFileSystemContol(DeviceObject %p Irp %p)\n", DeviceObject, Irp); + DPRINT("NpfsFileSystemContol(DeviceObject %p Irp %p)\n", DeviceObject, Irp); - DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; - IoStack = IoGetCurrentIrpStackLocation(Irp); - DPRINT("IoStack: %p\n", IoStack); - FileObject = IoStack->FileObject; - DPRINT("FileObject: %p\n", FileObject); - Ccb = FileObject->FsContext2; - DPRINT("CCB: %p\n", Ccb); - Fcb = Ccb->Fcb; - DPRINT("Pipe: %p\n", Fcb); - DPRINT("PipeName: %wZ\n", &Fcb->PipeName); + DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; + IoStack = IoGetCurrentIrpStackLocation(Irp); + DPRINT("IoStack: %p\n", IoStack); + FileObject = IoStack->FileObject; + DPRINT("FileObject: %p\n", FileObject); + Ccb = FileObject->FsContext2; + DPRINT("CCB: %p\n", Ccb); + Fcb = Ccb->Fcb; + DPRINT("Pipe: %p\n", Fcb); + DPRINT("PipeName: %wZ\n", &Fcb->PipeName); - Irp->IoStatus.Information = 0; + Irp->IoStatus.Information = 0; - switch (IoStack->Parameters.FileSystemControl.FsControlCode) - { - case FSCTL_PIPE_ASSIGN_EVENT: - DPRINT1("Assign event not implemented\n"); - Status = STATUS_NOT_IMPLEMENTED; - break; + switch (IoStack->Parameters.FileSystemControl.FsControlCode) + { + case FSCTL_PIPE_ASSIGN_EVENT: + DPRINT1("Assign event not implemented\n"); + Status = STATUS_NOT_IMPLEMENTED; + break; - case FSCTL_PIPE_DISCONNECT: - DPRINT("Disconnecting pipe %wZ\n", &Fcb->PipeName); - Status = NpfsDisconnectPipe(Ccb); - break; + case FSCTL_PIPE_DISCONNECT: + DPRINT("Disconnecting pipe %wZ\n", &Fcb->PipeName); + Status = NpfsDisconnectPipe(Ccb); + break; - case FSCTL_PIPE_LISTEN: - DPRINT("Connecting pipe %wZ\n", &Fcb->PipeName); - Status = NpfsConnectPipe(Irp, Ccb); - break; + case FSCTL_PIPE_LISTEN: + DPRINT("Connecting pipe %wZ\n", &Fcb->PipeName); + Status = NpfsConnectPipe(Irp, Ccb); + break; - case FSCTL_PIPE_PEEK: - DPRINT("Peeking pipe %wZ\n", &Fcb->PipeName); - Status = NpfsPeekPipe(Irp, (PIO_STACK_LOCATION)IoStack); - break; + case FSCTL_PIPE_PEEK: + DPRINT("Peeking pipe %wZ\n", &Fcb->PipeName); + Status = NpfsPeekPipe(Irp, (PIO_STACK_LOCATION)IoStack); + break; - case FSCTL_PIPE_QUERY_EVENT: - DPRINT1("Query event not implemented\n"); - Status = STATUS_NOT_IMPLEMENTED; - break; + case FSCTL_PIPE_QUERY_EVENT: + DPRINT1("Query event not implemented\n"); + Status = STATUS_NOT_IMPLEMENTED; + break; - case FSCTL_PIPE_TRANSCEIVE: - /* If you implement this, please remove the workaround in - lib/kernel32/file/npipe.c function TransactNamedPipe() */ - DPRINT1("Transceive not implemented\n"); - Status = STATUS_NOT_IMPLEMENTED; - break; + case FSCTL_PIPE_TRANSCEIVE: + /* If you implement this, please remove the workaround in + lib/kernel32/file/npipe.c function TransactNamedPipe() */ + DPRINT1("Transceive not implemented\n"); + Status = STATUS_NOT_IMPLEMENTED; + break; - case FSCTL_PIPE_WAIT: - DPRINT("Waiting for pipe %wZ\n", &Fcb->PipeName); - Status = NpfsWaitPipe(Irp, Ccb); - break; + case FSCTL_PIPE_WAIT: + DPRINT("Waiting for pipe %wZ\n", &Fcb->PipeName); + Status = NpfsWaitPipe(Irp, Ccb); + break; - case FSCTL_PIPE_IMPERSONATE: - DPRINT1("Impersonate not implemented\n"); - Status = STATUS_NOT_IMPLEMENTED; - break; + case FSCTL_PIPE_IMPERSONATE: + DPRINT1("Impersonate not implemented\n"); + Status = STATUS_NOT_IMPLEMENTED; + break; - case FSCTL_PIPE_SET_CLIENT_PROCESS: - DPRINT1("Set client process not implemented\n"); - Status = STATUS_NOT_IMPLEMENTED; - break; + case FSCTL_PIPE_SET_CLIENT_PROCESS: + DPRINT1("Set client process not implemented\n"); + Status = STATUS_NOT_IMPLEMENTED; + break; - case FSCTL_PIPE_QUERY_CLIENT_PROCESS: - DPRINT1("Query client process not implemented\n"); - Status = STATUS_NOT_IMPLEMENTED; - break; + case FSCTL_PIPE_QUERY_CLIENT_PROCESS: + DPRINT1("Query client process not implemented\n"); + Status = STATUS_NOT_IMPLEMENTED; + break; - case FSCTL_PIPE_INTERNAL_READ: - DPRINT1("Internal read not implemented\n"); - Status = STATUS_NOT_IMPLEMENTED; - break; + case FSCTL_PIPE_INTERNAL_READ: + DPRINT1("Internal read not implemented\n"); + Status = STATUS_NOT_IMPLEMENTED; + break; - case FSCTL_PIPE_INTERNAL_WRITE: - DPRINT1("Internal write not implemented\n"); - Status = STATUS_NOT_IMPLEMENTED; - break; + case FSCTL_PIPE_INTERNAL_WRITE: + DPRINT1("Internal write not implemented\n"); + Status = STATUS_NOT_IMPLEMENTED; + break; - case FSCTL_PIPE_INTERNAL_TRANSCEIVE: - DPRINT1("Internal transceive not implemented\n"); - Status = STATUS_NOT_IMPLEMENTED; - break; + case FSCTL_PIPE_INTERNAL_TRANSCEIVE: + DPRINT1("Internal transceive not implemented\n"); + Status = STATUS_NOT_IMPLEMENTED; + break; - case FSCTL_PIPE_INTERNAL_READ_OVFLOW: - DPRINT1("Internal read overflow not implemented\n"); - Status = STATUS_NOT_IMPLEMENTED; - break; + case FSCTL_PIPE_INTERNAL_READ_OVFLOW: + DPRINT1("Internal read overflow not implemented\n"); + Status = STATUS_NOT_IMPLEMENTED; + break; - default: - DPRINT1("Unrecognized IoControlCode: %x\n", - IoStack->Parameters.FileSystemControl.FsControlCode); - Status = STATUS_UNSUCCESSFUL; - } + default: + DPRINT1("Unrecognized IoControlCode: %x\n", + IoStack->Parameters.FileSystemControl.FsControlCode); + Status = STATUS_UNSUCCESSFUL; + } - if (Status != STATUS_PENDING) - { - Irp->IoStatus.Status = Status; + if (Status != STATUS_PENDING) + { + Irp->IoStatus.Status = Status; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - } + IoCompleteRequest(Irp, IO_NO_INCREMENT); + } - return Status; + return Status; } NTSTATUS STDCALL NpfsFlushBuffers(PDEVICE_OBJECT DeviceObject, - PIRP Irp) + PIRP Irp) { - /* FIXME: Implement */ + /* FIXME: Implement */ - Irp->IoStatus.Status = STATUS_SUCCESS; - Irp->IoStatus.Information = 0; + Irp->IoStatus.Status = STATUS_SUCCESS; + Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, IO_NO_INCREMENT); + IoCompleteRequest(Irp, IO_NO_INCREMENT); - return STATUS_SUCCESS; + return STATUS_SUCCESS; } /* EOF */ diff --git a/reactos/drivers/filesystems/npfs/npfs.c b/reactos/drivers/filesystems/npfs/npfs.c index 66ca097c4d9..5c9a5e04ed1 100644 --- a/reactos/drivers/filesystems/npfs/npfs.c +++ b/reactos/drivers/filesystems/npfs/npfs.c @@ -1,10 +1,10 @@ /* - * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel - * FILE: drivers/fs/np/mount.c - * PURPOSE: Named pipe filesystem - * PROGRAMMER: David Welch - */ +* COPYRIGHT: See COPYING in the top level directory +* PROJECT: ReactOS kernel +* FILE: drivers/fs/np/mount.c +* PURPOSE: Named pipe filesystem +* PROGRAMMER: David Welch +*/ /* INCLUDES ******************************************************************/ @@ -17,73 +17,73 @@ NTSTATUS STDCALL DriverEntry(PDRIVER_OBJECT DriverObject, - PUNICODE_STRING RegistryPath) + PUNICODE_STRING RegistryPath) { - PNPFS_DEVICE_EXTENSION DeviceExtension; - PDEVICE_OBJECT DeviceObject; - UNICODE_STRING DeviceName; - NTSTATUS Status; + PNPFS_DEVICE_EXTENSION DeviceExtension; + PDEVICE_OBJECT DeviceObject; + UNICODE_STRING DeviceName; + NTSTATUS Status; - DPRINT("Named Pipe FSD 0.0.2\n"); + DPRINT("Named Pipe FSD 0.0.2\n"); - ASSERT (sizeof(NPFS_CONTEXT) <= FIELD_OFFSET(IRP, Tail.Overlay.DriverContext)); - ASSERT (sizeof(NPFS_WAITER_ENTRY) <= FIELD_OFFSET(IRP, Tail.Overlay.DriverContext)); + ASSERT (sizeof(NPFS_CONTEXT) <= FIELD_OFFSET(IRP, Tail.Overlay.DriverContext)); + ASSERT (sizeof(NPFS_WAITER_ENTRY) <= FIELD_OFFSET(IRP, Tail.Overlay.DriverContext)); - DriverObject->MajorFunction[IRP_MJ_CREATE] = NpfsCreate; - DriverObject->MajorFunction[IRP_MJ_CREATE_NAMED_PIPE] = - NpfsCreateNamedPipe; - DriverObject->MajorFunction[IRP_MJ_CLOSE] = NpfsClose; - DriverObject->MajorFunction[IRP_MJ_READ] = NpfsRead; - DriverObject->MajorFunction[IRP_MJ_WRITE] = NpfsWrite; - DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = - NpfsQueryInformation; - DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = - NpfsSetInformation; - 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_DIRECTORY_CONTROL] = -// NpfsDirectoryControl; - DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = - NpfsFileSystemControl; -// DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY] = -// NpfsQuerySecurity; -// DriverObject->MajorFunction[IRP_MJ_SET_SECURITY] = -// NpfsSetSecurity; + DriverObject->MajorFunction[IRP_MJ_CREATE] = NpfsCreate; + DriverObject->MajorFunction[IRP_MJ_CREATE_NAMED_PIPE] = + NpfsCreateNamedPipe; + DriverObject->MajorFunction[IRP_MJ_CLOSE] = NpfsClose; + DriverObject->MajorFunction[IRP_MJ_READ] = NpfsRead; + DriverObject->MajorFunction[IRP_MJ_WRITE] = NpfsWrite; + DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = + NpfsQueryInformation; + DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = + NpfsSetInformation; + 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_DIRECTORY_CONTROL] = + // NpfsDirectoryControl; + DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = + NpfsFileSystemControl; + // DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY] = + // NpfsQuerySecurity; + // DriverObject->MajorFunction[IRP_MJ_SET_SECURITY] = + // NpfsSetSecurity; - DriverObject->DriverUnload = NULL; + DriverObject->DriverUnload = NULL; - RtlInitUnicodeString(&DeviceName, L"\\Device\\NamedPipe"); - Status = IoCreateDevice(DriverObject, - sizeof(NPFS_DEVICE_EXTENSION), - &DeviceName, - FILE_DEVICE_NAMED_PIPE, - 0, - FALSE, - &DeviceObject); - if (!NT_SUCCESS(Status)) - { - DPRINT("Failed to create named pipe device! (Status %x)\n", Status); - return Status; - } + RtlInitUnicodeString(&DeviceName, L"\\Device\\NamedPipe"); + Status = IoCreateDevice(DriverObject, + sizeof(NPFS_DEVICE_EXTENSION), + &DeviceName, + FILE_DEVICE_NAMED_PIPE, + 0, + FALSE, + &DeviceObject); + if (!NT_SUCCESS(Status)) + { + DPRINT("Failed to create named pipe device! (Status %x)\n", Status); + return Status; + } - /* initialize the device object */ - DeviceObject->Flags = DO_DIRECT_IO; + /* initialize the device object */ + DeviceObject->Flags = DO_DIRECT_IO; - /* initialize the device extension */ - DeviceExtension = DeviceObject->DeviceExtension; - InitializeListHead(&DeviceExtension->PipeListHead); - InitializeListHead(&DeviceExtension->ThreadListHead); - KeInitializeMutex(&DeviceExtension->PipeListLock, 0); - DeviceExtension->EmptyWaiterCount = 0; + /* initialize the device extension */ + DeviceExtension = DeviceObject->DeviceExtension; + InitializeListHead(&DeviceExtension->PipeListHead); + InitializeListHead(&DeviceExtension->ThreadListHead); + KeInitializeMutex(&DeviceExtension->PipeListLock, 0); + DeviceExtension->EmptyWaiterCount = 0; - /* set the size quotas */ - DeviceExtension->MinQuota = PAGE_SIZE; - DeviceExtension->DefaultQuota = 8 * PAGE_SIZE; - DeviceExtension->MaxQuota = 64 * PAGE_SIZE; + /* set the size quotas */ + DeviceExtension->MinQuota = PAGE_SIZE; + DeviceExtension->DefaultQuota = 8 * PAGE_SIZE; + DeviceExtension->MaxQuota = 64 * PAGE_SIZE; - return STATUS_SUCCESS; + return STATUS_SUCCESS; } /* EOF */ diff --git a/reactos/drivers/filesystems/npfs/npfs.h b/reactos/drivers/filesystems/npfs/npfs.h index 79be19417f3..522cd344eca 100644 --- a/reactos/drivers/filesystems/npfs/npfs.h +++ b/reactos/drivers/filesystems/npfs/npfs.h @@ -6,82 +6,82 @@ typedef struct _NPFS_DEVICE_EXTENSION { - LIST_ENTRY PipeListHead; - LIST_ENTRY ThreadListHead; - KMUTEX PipeListLock; - ULONG EmptyWaiterCount; - ULONG MinQuota; - ULONG DefaultQuota; - ULONG MaxQuota; + LIST_ENTRY PipeListHead; + LIST_ENTRY ThreadListHead; + KMUTEX PipeListLock; + ULONG EmptyWaiterCount; + ULONG MinQuota; + ULONG DefaultQuota; + ULONG MaxQuota; } NPFS_DEVICE_EXTENSION, *PNPFS_DEVICE_EXTENSION; typedef struct _NPFS_FCB { - FSRTL_COMMON_FCB_HEADER RFCB; - UNICODE_STRING PipeName; - LIST_ENTRY PipeListEntry; - KMUTEX CcbListLock; - LIST_ENTRY ServerCcbListHead; - LIST_ENTRY ClientCcbListHead; - LIST_ENTRY WaiterListHead; - LIST_ENTRY EmptyBufferListHead; - ULONG PipeType; - ULONG ReadMode; - ULONG WriteMode; - ULONG CompletionMode; - ULONG PipeConfiguration; - ULONG MaximumInstances; - ULONG CurrentInstances; - ULONG InboundQuota; - ULONG OutboundQuota; - LARGE_INTEGER TimeOut; + FSRTL_COMMON_FCB_HEADER RFCB; + UNICODE_STRING PipeName; + LIST_ENTRY PipeListEntry; + KMUTEX CcbListLock; + LIST_ENTRY ServerCcbListHead; + LIST_ENTRY ClientCcbListHead; + LIST_ENTRY WaiterListHead; + LIST_ENTRY EmptyBufferListHead; + ULONG PipeType; + ULONG ReadMode; + ULONG WriteMode; + ULONG CompletionMode; + ULONG PipeConfiguration; + ULONG MaximumInstances; + ULONG CurrentInstances; + ULONG InboundQuota; + ULONG OutboundQuota; + LARGE_INTEGER TimeOut; } NPFS_FCB, *PNPFS_FCB; typedef struct _NPFS_CCB { - LIST_ENTRY CcbListEntry; - struct _NPFS_CCB* OtherSide; - struct ETHREAD *Thread; - PNPFS_FCB Fcb; - KEVENT ConnectEvent; - KEVENT ReadEvent; - KEVENT WriteEvent; - ULONG PipeEnd; - ULONG PipeState; - ULONG ReadDataAvailable; - ULONG WriteQuotaAvailable; + LIST_ENTRY CcbListEntry; + struct _NPFS_CCB* OtherSide; + struct ETHREAD *Thread; + PNPFS_FCB Fcb; + KEVENT ConnectEvent; + KEVENT ReadEvent; + KEVENT WriteEvent; + ULONG PipeEnd; + ULONG PipeState; + ULONG ReadDataAvailable; + ULONG WriteQuotaAvailable; - LIST_ENTRY ReadRequestListHead; + LIST_ENTRY ReadRequestListHead; - PVOID Data; - PVOID ReadPtr; - PVOID WritePtr; - ULONG MaxDataLength; + PVOID Data; + PVOID ReadPtr; + PVOID WritePtr; + ULONG MaxDataLength; - FAST_MUTEX DataListLock; /* Data queue lock */ + FAST_MUTEX DataListLock; /* Data queue lock */ } NPFS_CCB, *PNPFS_CCB; typedef struct _NPFS_CONTEXT { - LIST_ENTRY ListEntry; - PKEVENT WaitEvent; + LIST_ENTRY ListEntry; + PKEVENT WaitEvent; } NPFS_CONTEXT, *PNPFS_CONTEXT; typedef struct _NPFS_THREAD_CONTEXT { - ULONG Count; - KEVENT Event; - PNPFS_DEVICE_EXTENSION DeviceExt; - LIST_ENTRY ListEntry; - PVOID WaitObjectArray[MAXIMUM_WAIT_OBJECTS]; - KWAIT_BLOCK WaitBlockArray[MAXIMUM_WAIT_OBJECTS]; - PIRP WaitIrpArray[MAXIMUM_WAIT_OBJECTS]; + ULONG Count; + KEVENT Event; + PNPFS_DEVICE_EXTENSION DeviceExt; + LIST_ENTRY ListEntry; + PVOID WaitObjectArray[MAXIMUM_WAIT_OBJECTS]; + KWAIT_BLOCK WaitBlockArray[MAXIMUM_WAIT_OBJECTS]; + PIRP WaitIrpArray[MAXIMUM_WAIT_OBJECTS]; } NPFS_THREAD_CONTEXT, *PNPFS_THREAD_CONTEXT; typedef struct _NPFS_WAITER_ENTRY { - LIST_ENTRY Entry; - PNPFS_CCB Ccb; + LIST_ENTRY Entry; + PNPFS_CCB Ccb; } NPFS_WAITER_ENTRY, *PNPFS_WAITER_ENTRY; @@ -89,10 +89,10 @@ extern NPAGED_LOOKASIDE_LIST NpfsPipeDataLookasideList; #define KeLockMutex(x) KeWaitForSingleObject(x, \ - UserRequest, \ - KernelMode, \ - FALSE, \ - NULL); + UserRequest, \ + KernelMode, \ + FALSE, \ + NULL); #define KeUnlockMutex(x) KeReleaseMutex(x, FALSE); @@ -117,6 +117,6 @@ NTSTATUS STDCALL NpfsQueryVolumeInformation (PDEVICE_OBJECT DeviceObject, PIRP I NTSTATUS STDCALL DriverEntry(PDRIVER_OBJECT DriverObject, - PUNICODE_STRING RegistryPath); + PUNICODE_STRING RegistryPath); #endif /* __DRIVERS_FS_NP_NPFS_H */ diff --git a/reactos/drivers/filesystems/npfs/rw.c b/reactos/drivers/filesystems/npfs/rw.c index fad96b6058b..ab3553a611b 100644 --- a/reactos/drivers/filesystems/npfs/rw.c +++ b/reactos/drivers/filesystems/npfs/rw.c @@ -1,10 +1,10 @@ /* - * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel - * FILE: drivers/fs/np/rw.c - * PURPOSE: Named pipe filesystem - * PROGRAMMER: David Welch - */ +* COPYRIGHT: See COPYING in the top level directory +* PROJECT: ReactOS kernel +* FILE: drivers/fs/np/rw.c +* PURPOSE: Named pipe filesystem +* PROGRAMMER: David Welch +*/ /* INCLUDES ******************************************************************/ @@ -18,761 +18,761 @@ #ifndef NDEBUG VOID HexDump(PUCHAR Buffer, ULONG Length) { - CHAR Line[65]; - UCHAR ch; - const char Hex[] = "0123456789ABCDEF"; - int i, j; + CHAR Line[65]; + UCHAR ch; + const char Hex[] = "0123456789ABCDEF"; + int i, j; - DbgPrint("---------------\n"); + DbgPrint("---------------\n"); - for (i = 0; i < Length; i+= 16) - { - memset(Line, ' ', 64); - Line[64] = 0; + for (i = 0; i < Length; i+= 16) + { + memset(Line, ' ', 64); + Line[64] = 0; - for (j = 0; j < 16 && j + i < Length; j++) - { - ch = Buffer[i + j]; - Line[3*j + 0] = Hex[ch >> 4]; - Line[3*j + 1] = Hex[ch & 0x0f]; - Line[48 + j] = isprint(ch) ? ch : '.'; - } - DbgPrint("%s\n", Line); - } - DbgPrint("---------------\n"); + for (j = 0; j < 16 && j + i < Length; j++) + { + ch = Buffer[i + j]; + Line[3*j + 0] = Hex[ch >> 4]; + Line[3*j + 1] = Hex[ch & 0x0f]; + Line[48 + j] = isprint(ch) ? ch : '.'; + } + DbgPrint("%s\n", Line); + } + DbgPrint("---------------\n"); } #endif static VOID STDCALL NpfsReadWriteCancelRoutine(IN PDEVICE_OBJECT DeviceObject, - IN PIRP Irp) + IN PIRP Irp) { - PNPFS_CONTEXT Context; - PNPFS_DEVICE_EXTENSION DeviceExt; - PIO_STACK_LOCATION IoStack; - PNPFS_CCB Ccb; - BOOLEAN Complete = FALSE; + PNPFS_CONTEXT Context; + PNPFS_DEVICE_EXTENSION DeviceExt; + PIO_STACK_LOCATION IoStack; + PNPFS_CCB Ccb; + BOOLEAN Complete = FALSE; - DPRINT("NpfsReadWriteCancelRoutine(DeviceObject %x, Irp %x)\n", DeviceObject, Irp); + DPRINT("NpfsReadWriteCancelRoutine(DeviceObject %x, Irp %x)\n", DeviceObject, Irp); - IoReleaseCancelSpinLock(Irp->CancelIrql); + IoReleaseCancelSpinLock(Irp->CancelIrql); - Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext; - DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; - IoStack = IoGetCurrentIrpStackLocation(Irp); - Ccb = IoStack->FileObject->FsContext2; + Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext; + DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; + IoStack = IoGetCurrentIrpStackLocation(Irp); + Ccb = IoStack->FileObject->FsContext2; - KeLockMutex(&DeviceExt->PipeListLock); - ExAcquireFastMutex(&Ccb->DataListLock); - switch(IoStack->MajorFunction) - { - case IRP_MJ_READ: - if (Ccb->ReadRequestListHead.Flink != &Context->ListEntry) - { - /* we are not the first in the list, remove an complete us */ - RemoveEntryList(&Context->ListEntry); - Complete = TRUE; - } - else - { - KeSetEvent(&Ccb->ReadEvent, IO_NO_INCREMENT, FALSE); - } - break; - default: - KEBUGCHECK(0); - } - ExReleaseFastMutex(&Ccb->DataListLock); - KeUnlockMutex(&DeviceExt->PipeListLock); - if (Complete) - { - Irp->IoStatus.Status = STATUS_CANCELLED; - Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - } + KeLockMutex(&DeviceExt->PipeListLock); + ExAcquireFastMutex(&Ccb->DataListLock); + switch(IoStack->MajorFunction) + { + case IRP_MJ_READ: + if (Ccb->ReadRequestListHead.Flink != &Context->ListEntry) + { + /* we are not the first in the list, remove an complete us */ + RemoveEntryList(&Context->ListEntry); + Complete = TRUE; + } + else + { + KeSetEvent(&Ccb->ReadEvent, IO_NO_INCREMENT, FALSE); + } + break; + default: + KEBUGCHECK(0); + } + ExReleaseFastMutex(&Ccb->DataListLock); + KeUnlockMutex(&DeviceExt->PipeListLock); + if (Complete) + { + Irp->IoStatus.Status = STATUS_CANCELLED; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + } } static VOID STDCALL NpfsWaiterThread(PVOID InitContext) { - PNPFS_THREAD_CONTEXT ThreadContext = (PNPFS_THREAD_CONTEXT) InitContext; - ULONG CurrentCount; - ULONG Count = 0; - PIRP Irp = NULL; - PIRP NextIrp; - NTSTATUS Status; - BOOLEAN Terminate = FALSE; - BOOLEAN Cancel = FALSE; - PIO_STACK_LOCATION IoStack = NULL; - PNPFS_CONTEXT Context; - PNPFS_CONTEXT NextContext; - PNPFS_CCB Ccb; + PNPFS_THREAD_CONTEXT ThreadContext = (PNPFS_THREAD_CONTEXT) InitContext; + ULONG CurrentCount; + ULONG Count = 0; + PIRP Irp = NULL; + PIRP NextIrp; + NTSTATUS Status; + BOOLEAN Terminate = FALSE; + BOOLEAN Cancel = FALSE; + PIO_STACK_LOCATION IoStack = NULL; + PNPFS_CONTEXT Context; + PNPFS_CONTEXT NextContext; + PNPFS_CCB Ccb; - KeLockMutex(&ThreadContext->DeviceExt->PipeListLock); + KeLockMutex(&ThreadContext->DeviceExt->PipeListLock); - while (1) - { - CurrentCount = ThreadContext->Count; - KeUnlockMutex(&ThreadContext->DeviceExt->PipeListLock); - if (Irp) - { - if (Cancel) - { - Irp->IoStatus.Status = STATUS_CANCELLED; - Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, IO_NO_INCREMENT); - } - else - { - switch (IoStack->MajorFunction) - { - case IRP_MJ_READ: - NpfsRead(IoStack->DeviceObject, Irp); - break; - default: - KEBUGCHECK(0); - } - } - } - if (Terminate) - { - break; - } - Status = KeWaitForMultipleObjects(CurrentCount, - ThreadContext->WaitObjectArray, - WaitAny, - Executive, - KernelMode, - FALSE, - NULL, - ThreadContext->WaitBlockArray); - if (!NT_SUCCESS(Status)) - { - KEBUGCHECK(0); - } - KeLockMutex(&ThreadContext->DeviceExt->PipeListLock); - Count = Status - STATUS_SUCCESS; - ASSERT (Count < CurrentCount); - if (Count > 0) - { - Irp = ThreadContext->WaitIrpArray[Count]; - ThreadContext->Count--; - ThreadContext->DeviceExt->EmptyWaiterCount++; - ThreadContext->WaitObjectArray[Count] = ThreadContext->WaitObjectArray[ThreadContext->Count]; - ThreadContext->WaitIrpArray[Count] = ThreadContext->WaitIrpArray[ThreadContext->Count]; + while (1) + { + CurrentCount = ThreadContext->Count; + KeUnlockMutex(&ThreadContext->DeviceExt->PipeListLock); + if (Irp) + { + if (Cancel) + { + Irp->IoStatus.Status = STATUS_CANCELLED; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + } + else + { + switch (IoStack->MajorFunction) + { + case IRP_MJ_READ: + NpfsRead(IoStack->DeviceObject, Irp); + break; + default: + KEBUGCHECK(0); + } + } + } + if (Terminate) + { + break; + } + Status = KeWaitForMultipleObjects(CurrentCount, + ThreadContext->WaitObjectArray, + WaitAny, + Executive, + KernelMode, + FALSE, + NULL, + ThreadContext->WaitBlockArray); + if (!NT_SUCCESS(Status)) + { + KEBUGCHECK(0); + } + KeLockMutex(&ThreadContext->DeviceExt->PipeListLock); + Count = Status - STATUS_SUCCESS; + ASSERT (Count < CurrentCount); + if (Count > 0) + { + Irp = ThreadContext->WaitIrpArray[Count]; + ThreadContext->Count--; + ThreadContext->DeviceExt->EmptyWaiterCount++; + ThreadContext->WaitObjectArray[Count] = ThreadContext->WaitObjectArray[ThreadContext->Count]; + ThreadContext->WaitIrpArray[Count] = ThreadContext->WaitIrpArray[ThreadContext->Count]; - Cancel = (NULL == IoSetCancelRoutine(Irp, NULL)); - Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext; - IoStack = IoGetCurrentIrpStackLocation(Irp); + Cancel = (NULL == IoSetCancelRoutine(Irp, NULL)); + Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext; + IoStack = IoGetCurrentIrpStackLocation(Irp); - if (Cancel) - { - Ccb = IoStack->FileObject->FsContext2; - ExAcquireFastMutex(&Ccb->DataListLock); - RemoveEntryList(&Context->ListEntry); - switch (IoStack->MajorFunction) - { - case IRP_MJ_READ: - if (!IsListEmpty(&Ccb->ReadRequestListHead)) - { - /* put the next request on the wait list */ - NextContext = CONTAINING_RECORD(Ccb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry); - ThreadContext->WaitObjectArray[ThreadContext->Count] = NextContext->WaitEvent; - NextIrp = CONTAINING_RECORD(NextContext, IRP, Tail.Overlay.DriverContext); - ThreadContext->WaitIrpArray[ThreadContext->Count] = NextIrp; - ThreadContext->Count++; - ThreadContext->DeviceExt->EmptyWaiterCount--; - } - break; - default: - KEBUGCHECK(0); - } - ExReleaseFastMutex(&Ccb->DataListLock); - } - } - else - { - /* someone has add a new wait request */ - Irp = NULL; - } - if (ThreadContext->Count == 1 && ThreadContext->DeviceExt->EmptyWaiterCount >= MAXIMUM_WAIT_OBJECTS) - { - /* it exist an other thread with empty wait slots, we can remove our thread from the list */ - RemoveEntryList(&ThreadContext->ListEntry); - ThreadContext->DeviceExt->EmptyWaiterCount -= MAXIMUM_WAIT_OBJECTS - 1; - Terminate = TRUE; - } - } - ExFreePool(ThreadContext); + if (Cancel) + { + Ccb = IoStack->FileObject->FsContext2; + ExAcquireFastMutex(&Ccb->DataListLock); + RemoveEntryList(&Context->ListEntry); + switch (IoStack->MajorFunction) + { + case IRP_MJ_READ: + if (!IsListEmpty(&Ccb->ReadRequestListHead)) + { + /* put the next request on the wait list */ + NextContext = CONTAINING_RECORD(Ccb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry); + ThreadContext->WaitObjectArray[ThreadContext->Count] = NextContext->WaitEvent; + NextIrp = CONTAINING_RECORD(NextContext, IRP, Tail.Overlay.DriverContext); + ThreadContext->WaitIrpArray[ThreadContext->Count] = NextIrp; + ThreadContext->Count++; + ThreadContext->DeviceExt->EmptyWaiterCount--; + } + break; + default: + KEBUGCHECK(0); + } + ExReleaseFastMutex(&Ccb->DataListLock); + } + } + else + { + /* someone has add a new wait request */ + Irp = NULL; + } + if (ThreadContext->Count == 1 && ThreadContext->DeviceExt->EmptyWaiterCount >= MAXIMUM_WAIT_OBJECTS) + { + /* it exist an other thread with empty wait slots, we can remove our thread from the list */ + RemoveEntryList(&ThreadContext->ListEntry); + ThreadContext->DeviceExt->EmptyWaiterCount -= MAXIMUM_WAIT_OBJECTS - 1; + Terminate = TRUE; + } + } + ExFreePool(ThreadContext); } static NTSTATUS NpfsAddWaitingReadWriteRequest(IN PDEVICE_OBJECT DeviceObject, - IN PIRP Irp) + IN PIRP Irp) { - PLIST_ENTRY ListEntry; - PNPFS_THREAD_CONTEXT ThreadContext = NULL; - NTSTATUS Status; - HANDLE hThread; - KIRQL oldIrql; + PLIST_ENTRY ListEntry; + PNPFS_THREAD_CONTEXT ThreadContext = NULL; + NTSTATUS Status; + HANDLE hThread; + KIRQL oldIrql; - PNPFS_CONTEXT Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext; - PNPFS_DEVICE_EXTENSION DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; + PNPFS_CONTEXT Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext; + PNPFS_DEVICE_EXTENSION DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension; - DPRINT("NpfsAddWaitingReadWriteRequest(DeviceObject %p, Irp %p)\n", DeviceObject, Irp); + DPRINT("NpfsAddWaitingReadWriteRequest(DeviceObject %p, Irp %p)\n", DeviceObject, Irp); - KeLockMutex(&DeviceExt->PipeListLock); + KeLockMutex(&DeviceExt->PipeListLock); - ListEntry = DeviceExt->ThreadListHead.Flink; - while (ListEntry != &DeviceExt->ThreadListHead) - { - ThreadContext = CONTAINING_RECORD(ListEntry, NPFS_THREAD_CONTEXT, ListEntry); - if (ThreadContext->Count < MAXIMUM_WAIT_OBJECTS) - { - break; - } - ListEntry = ListEntry->Flink; - } - if (ListEntry == &DeviceExt->ThreadListHead) - { - ThreadContext = ExAllocatePool(NonPagedPool, sizeof(NPFS_THREAD_CONTEXT)); - if (ThreadContext == NULL) - { - KeUnlockMutex(&DeviceExt->PipeListLock); - return STATUS_NO_MEMORY; - } - ThreadContext->DeviceExt = DeviceExt; - KeInitializeEvent(&ThreadContext->Event, SynchronizationEvent, FALSE); - ThreadContext->Count = 1; - ThreadContext->WaitObjectArray[0] = &ThreadContext->Event; + ListEntry = DeviceExt->ThreadListHead.Flink; + while (ListEntry != &DeviceExt->ThreadListHead) + { + ThreadContext = CONTAINING_RECORD(ListEntry, NPFS_THREAD_CONTEXT, ListEntry); + if (ThreadContext->Count < MAXIMUM_WAIT_OBJECTS) + { + break; + } + ListEntry = ListEntry->Flink; + } + if (ListEntry == &DeviceExt->ThreadListHead) + { + ThreadContext = ExAllocatePool(NonPagedPool, sizeof(NPFS_THREAD_CONTEXT)); + if (ThreadContext == NULL) + { + KeUnlockMutex(&DeviceExt->PipeListLock); + return STATUS_NO_MEMORY; + } + ThreadContext->DeviceExt = DeviceExt; + KeInitializeEvent(&ThreadContext->Event, SynchronizationEvent, FALSE); + ThreadContext->Count = 1; + ThreadContext->WaitObjectArray[0] = &ThreadContext->Event; - DPRINT("Creating a new system thread for waiting read/write requests\n"); + DPRINT("Creating a new system thread for waiting read/write requests\n"); - Status = PsCreateSystemThread(&hThread, - THREAD_ALL_ACCESS, - NULL, - NULL, - NULL, - NpfsWaiterThread, - (PVOID)ThreadContext); - if (!NT_SUCCESS(Status)) - { - ExFreePool(ThreadContext); - KeUnlockMutex(&DeviceExt->PipeListLock); - return Status; - } - InsertHeadList(&DeviceExt->ThreadListHead, &ThreadContext->ListEntry); - DeviceExt->EmptyWaiterCount += MAXIMUM_WAIT_OBJECTS - 1; - } - IoMarkIrpPending(Irp); + Status = PsCreateSystemThread(&hThread, + THREAD_ALL_ACCESS, + NULL, + NULL, + NULL, + NpfsWaiterThread, + (PVOID)ThreadContext); + if (!NT_SUCCESS(Status)) + { + ExFreePool(ThreadContext); + KeUnlockMutex(&DeviceExt->PipeListLock); + return Status; + } + InsertHeadList(&DeviceExt->ThreadListHead, &ThreadContext->ListEntry); + DeviceExt->EmptyWaiterCount += MAXIMUM_WAIT_OBJECTS - 1; + } + IoMarkIrpPending(Irp); - IoAcquireCancelSpinLock(&oldIrql); - if (Irp->Cancel) - { - IoReleaseCancelSpinLock(oldIrql); - Status = STATUS_CANCELLED; - } - else - { - (void)IoSetCancelRoutine(Irp, NpfsReadWriteCancelRoutine); - IoReleaseCancelSpinLock(oldIrql); - ThreadContext->WaitObjectArray[ThreadContext->Count] = Context->WaitEvent; - ThreadContext->WaitIrpArray[ThreadContext->Count] = Irp; - ThreadContext->Count++; - DeviceExt->EmptyWaiterCount--; - KeSetEvent(&ThreadContext->Event, IO_NO_INCREMENT, FALSE); - Status = STATUS_SUCCESS; - } - KeUnlockMutex(&DeviceExt->PipeListLock); - return Status; + IoAcquireCancelSpinLock(&oldIrql); + if (Irp->Cancel) + { + IoReleaseCancelSpinLock(oldIrql); + Status = STATUS_CANCELLED; + } + else + { + (void)IoSetCancelRoutine(Irp, NpfsReadWriteCancelRoutine); + IoReleaseCancelSpinLock(oldIrql); + ThreadContext->WaitObjectArray[ThreadContext->Count] = Context->WaitEvent; + ThreadContext->WaitIrpArray[ThreadContext->Count] = Irp; + ThreadContext->Count++; + DeviceExt->EmptyWaiterCount--; + KeSetEvent(&ThreadContext->Event, IO_NO_INCREMENT, FALSE); + Status = STATUS_SUCCESS; + } + KeUnlockMutex(&DeviceExt->PipeListLock); + return Status; } NTSTATUS STDCALL NpfsRead(IN PDEVICE_OBJECT DeviceObject, - IN PIRP Irp) + IN PIRP Irp) { - PFILE_OBJECT FileObject; - NTSTATUS Status; - NTSTATUS OriginalStatus = STATUS_SUCCESS; - PNPFS_CCB Ccb; - PNPFS_CONTEXT Context; - KEVENT Event; - ULONG Length; - ULONG Information = 0; - ULONG CopyLength; - ULONG TempLength; - BOOLEAN IsOriginalRequest = TRUE; - PVOID Buffer; + PFILE_OBJECT FileObject; + NTSTATUS Status; + NTSTATUS OriginalStatus = STATUS_SUCCESS; + PNPFS_CCB Ccb; + PNPFS_CONTEXT Context; + KEVENT Event; + ULONG Length; + ULONG Information = 0; + ULONG CopyLength; + ULONG TempLength; + BOOLEAN IsOriginalRequest = TRUE; + PVOID Buffer; - DPRINT("NpfsRead(DeviceObject %p, Irp %p)\n", DeviceObject, Irp); + DPRINT("NpfsRead(DeviceObject %p, Irp %p)\n", DeviceObject, Irp); - if (Irp->MdlAddress == NULL) - { - DPRINT("Irp->MdlAddress == NULL\n"); - Status = STATUS_UNSUCCESSFUL; - Irp->IoStatus.Information = 0; - goto done; - } - - FileObject = IoGetCurrentIrpStackLocation(Irp)->FileObject; - Ccb = FileObject->FsContext2; - Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext; - - if (Ccb->OtherSide == NULL) - { - DPRINT("Pipe is NOT connected!\n"); - if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE) - Status = STATUS_PIPE_LISTENING; - else if (Ccb->PipeState == FILE_PIPE_DISCONNECTED_STATE) - Status = STATUS_PIPE_DISCONNECTED; - else - Status = STATUS_UNSUCCESSFUL; - Irp->IoStatus.Information = 0; - goto done; - } - - if (Ccb->Data == NULL) - { - DPRINT1("Pipe is NOT readable!\n"); - Status = STATUS_UNSUCCESSFUL; - Irp->IoStatus.Information = 0; - goto done; - } - - ExAcquireFastMutex(&Ccb->DataListLock); - - if (IoIsOperationSynchronous(Irp)) - { - InsertTailList(&Ccb->ReadRequestListHead, &Context->ListEntry); - if (Ccb->ReadRequestListHead.Flink != &Context->ListEntry) - { - KeInitializeEvent(&Event, SynchronizationEvent, FALSE); - Context->WaitEvent = &Event; - ExReleaseFastMutex(&Ccb->DataListLock); - Status = KeWaitForSingleObject(&Event, - Executive, - KernelMode, - FALSE, - NULL); - if (!NT_SUCCESS(Status)) + if (Irp->MdlAddress == NULL) { - KEBUGCHECK(0); + DPRINT("Irp->MdlAddress == NULL\n"); + Status = STATUS_UNSUCCESSFUL; + Irp->IoStatus.Information = 0; + goto done; } - ExAcquireFastMutex(&Ccb->DataListLock); - } - Irp->IoStatus.Information = 0; - } - else - { - KIRQL oldIrql; - if (IsListEmpty(&Ccb->ReadRequestListHead) || - Ccb->ReadRequestListHead.Flink != &Context->ListEntry) - { - /* this is a new request */ - Irp->IoStatus.Information = 0; - Context->WaitEvent = &Ccb->ReadEvent; - InsertTailList(&Ccb->ReadRequestListHead, &Context->ListEntry); - if (Ccb->ReadRequestListHead.Flink != &Context->ListEntry) + + FileObject = IoGetCurrentIrpStackLocation(Irp)->FileObject; + Ccb = FileObject->FsContext2; + Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext; + + if (Ccb->OtherSide == NULL) { - /* there was already a request on the list */ - IoAcquireCancelSpinLock(&oldIrql); - if (Irp->Cancel) - { - IoReleaseCancelSpinLock(oldIrql); - RemoveEntryList(&Context->ListEntry); - ExReleaseFastMutex(&Ccb->DataListLock); - Status = STATUS_CANCELLED; - goto done; - } - (void)IoSetCancelRoutine(Irp, NpfsReadWriteCancelRoutine); - IoReleaseCancelSpinLock(oldIrql); - ExReleaseFastMutex(&Ccb->DataListLock); - IoMarkIrpPending(Irp); - Status = STATUS_PENDING; - goto done; + DPRINT("Pipe is NOT connected!\n"); + if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE) + Status = STATUS_PIPE_LISTENING; + else if (Ccb->PipeState == FILE_PIPE_DISCONNECTED_STATE) + Status = STATUS_PIPE_DISCONNECTED; + else + Status = STATUS_UNSUCCESSFUL; + Irp->IoStatus.Information = 0; + goto done; } - } - } - while (1) - { - Buffer = MmGetSystemAddressForMdl(Irp->MdlAddress); - Information = Irp->IoStatus.Information; - Length = IoGetCurrentIrpStackLocation(Irp)->Parameters.Read.Length; - ASSERT (Information <= Length); - Buffer = (PVOID)((ULONG_PTR)Buffer + Information); - Length -= Information; - Status = STATUS_SUCCESS; + if (Ccb->Data == NULL) + { + DPRINT1("Pipe is NOT readable!\n"); + Status = STATUS_UNSUCCESSFUL; + Irp->IoStatus.Information = 0; + goto done; + } - while (1) - { - if (Ccb->ReadDataAvailable == 0) - { - if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) - { - ASSERT(Ccb->OtherSide != NULL); - KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE); - } - if (Information > 0 && - (Ccb->Fcb->ReadMode != FILE_PIPE_BYTE_STREAM_MODE || - Ccb->PipeState != FILE_PIPE_CONNECTED_STATE)) - { - break; - } - if (Ccb->PipeState != FILE_PIPE_CONNECTED_STATE) - { - DPRINT("PipeState: %x\n", Ccb->PipeState); - Status = STATUS_PIPE_BROKEN; - break; - } - ExReleaseFastMutex(&Ccb->DataListLock); - if (IoIsOperationSynchronous(Irp)) - { - /* Wait for ReadEvent to become signaled */ + ExAcquireFastMutex(&Ccb->DataListLock); - DPRINT("Waiting for readable data (%wZ)\n", &Ccb->Fcb->PipeName); - Status = KeWaitForSingleObject(&Ccb->ReadEvent, - UserRequest, - KernelMode, - FALSE, - NULL); - DPRINT("Finished waiting (%wZ)! Status: %x\n", &Ccb->Fcb->PipeName, Status); - ExAcquireFastMutex(&Ccb->DataListLock); - } - else - { - Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext; + if (IoIsOperationSynchronous(Irp)) + { + InsertTailList(&Ccb->ReadRequestListHead, &Context->ListEntry); + if (Ccb->ReadRequestListHead.Flink != &Context->ListEntry) + { + KeInitializeEvent(&Event, SynchronizationEvent, FALSE); + Context->WaitEvent = &Event; + ExReleaseFastMutex(&Ccb->DataListLock); + Status = KeWaitForSingleObject(&Event, + Executive, + KernelMode, + FALSE, + NULL); + if (!NT_SUCCESS(Status)) + { + KEBUGCHECK(0); + } + ExAcquireFastMutex(&Ccb->DataListLock); + } + Irp->IoStatus.Information = 0; + } + else + { + KIRQL oldIrql; + if (IsListEmpty(&Ccb->ReadRequestListHead) || + Ccb->ReadRequestListHead.Flink != &Context->ListEntry) + { + /* this is a new request */ + Irp->IoStatus.Information = 0; + Context->WaitEvent = &Ccb->ReadEvent; + InsertTailList(&Ccb->ReadRequestListHead, &Context->ListEntry); + if (Ccb->ReadRequestListHead.Flink != &Context->ListEntry) + { + /* there was already a request on the list */ + IoAcquireCancelSpinLock(&oldIrql); + if (Irp->Cancel) + { + IoReleaseCancelSpinLock(oldIrql); + RemoveEntryList(&Context->ListEntry); + ExReleaseFastMutex(&Ccb->DataListLock); + Status = STATUS_CANCELLED; + goto done; + } + (void)IoSetCancelRoutine(Irp, NpfsReadWriteCancelRoutine); + IoReleaseCancelSpinLock(oldIrql); + ExReleaseFastMutex(&Ccb->DataListLock); + IoMarkIrpPending(Irp); + Status = STATUS_PENDING; + goto done; + } + } + } - Context->WaitEvent = &Ccb->ReadEvent; - Status = NpfsAddWaitingReadWriteRequest(DeviceObject, Irp); + while (1) + { + Buffer = MmGetSystemAddressForMdl(Irp->MdlAddress); + Information = Irp->IoStatus.Information; + Length = IoGetCurrentIrpStackLocation(Irp)->Parameters.Read.Length; + ASSERT (Information <= Length); + Buffer = (PVOID)((ULONG_PTR)Buffer + Information); + Length -= Information; + Status = STATUS_SUCCESS; - if (NT_SUCCESS(Status)) - { - Status = STATUS_PENDING; - } - ExAcquireFastMutex(&Ccb->DataListLock); - break; - } - } - ASSERT(IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL); - if (Ccb->Fcb->ReadMode == FILE_PIPE_BYTE_STREAM_MODE) - { - DPRINT("Byte stream mode\n"); - /* Byte stream mode */ - while (Length > 0 && Ccb->ReadDataAvailable > 0) - { - CopyLength = min(Ccb->ReadDataAvailable, Length); - if ((ULONG_PTR)Ccb->ReadPtr + CopyLength <= (ULONG_PTR)Ccb->Data + Ccb->MaxDataLength) - { - memcpy(Buffer, Ccb->ReadPtr, CopyLength); - Ccb->ReadPtr = (PVOID)((ULONG_PTR)Ccb->ReadPtr + CopyLength); - if (Ccb->ReadPtr == (PVOID)((ULONG_PTR)Ccb->Data + Ccb->MaxDataLength)) - { - Ccb->ReadPtr = Ccb->Data; - } - } - else - { - TempLength = (ULONG)((ULONG_PTR)Ccb->Data + Ccb->MaxDataLength - (ULONG_PTR)Ccb->ReadPtr); - memcpy(Buffer, Ccb->ReadPtr, TempLength); - memcpy((PVOID)((ULONG_PTR)Buffer + TempLength), Ccb->Data, CopyLength - TempLength); - Ccb->ReadPtr = (PVOID)((ULONG_PTR)Ccb->Data + CopyLength - TempLength); - } + while (1) + { + if (Ccb->ReadDataAvailable == 0) + { + if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) + { + ASSERT(Ccb->OtherSide != NULL); + KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE); + } + if (Information > 0 && + (Ccb->Fcb->ReadMode != FILE_PIPE_BYTE_STREAM_MODE || + Ccb->PipeState != FILE_PIPE_CONNECTED_STATE)) + { + break; + } + if (Ccb->PipeState != FILE_PIPE_CONNECTED_STATE) + { + DPRINT("PipeState: %x\n", Ccb->PipeState); + Status = STATUS_PIPE_BROKEN; + break; + } + ExReleaseFastMutex(&Ccb->DataListLock); + if (IoIsOperationSynchronous(Irp)) + { + /* Wait for ReadEvent to become signaled */ - Buffer = (PVOID)((ULONG_PTR)Buffer + CopyLength); - Length -= CopyLength; - Information += CopyLength; + DPRINT("Waiting for readable data (%wZ)\n", &Ccb->Fcb->PipeName); + Status = KeWaitForSingleObject(&Ccb->ReadEvent, + UserRequest, + KernelMode, + FALSE, + NULL); + DPRINT("Finished waiting (%wZ)! Status: %x\n", &Ccb->Fcb->PipeName, Status); + ExAcquireFastMutex(&Ccb->DataListLock); + } + else + { + Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext; - Ccb->ReadDataAvailable -= CopyLength; - Ccb->WriteQuotaAvailable += CopyLength; - } + Context->WaitEvent = &Ccb->ReadEvent; + Status = NpfsAddWaitingReadWriteRequest(DeviceObject, Irp); - if (Length == 0) - { - if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) - { - KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE); - } - KeResetEvent(&Ccb->ReadEvent); - break; - } - } - else - { - DPRINT("Message mode\n"); + if (NT_SUCCESS(Status)) + { + Status = STATUS_PENDING; + } + ExAcquireFastMutex(&Ccb->DataListLock); + break; + } + } + ASSERT(IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL); + if (Ccb->Fcb->ReadMode == FILE_PIPE_BYTE_STREAM_MODE) + { + DPRINT("Byte stream mode\n"); + /* Byte stream mode */ + while (Length > 0 && Ccb->ReadDataAvailable > 0) + { + CopyLength = min(Ccb->ReadDataAvailable, Length); + if ((ULONG_PTR)Ccb->ReadPtr + CopyLength <= (ULONG_PTR)Ccb->Data + Ccb->MaxDataLength) + { + memcpy(Buffer, Ccb->ReadPtr, CopyLength); + Ccb->ReadPtr = (PVOID)((ULONG_PTR)Ccb->ReadPtr + CopyLength); + if (Ccb->ReadPtr == (PVOID)((ULONG_PTR)Ccb->Data + Ccb->MaxDataLength)) + { + Ccb->ReadPtr = Ccb->Data; + } + } + else + { + TempLength = (ULONG)((ULONG_PTR)Ccb->Data + Ccb->MaxDataLength - (ULONG_PTR)Ccb->ReadPtr); + memcpy(Buffer, Ccb->ReadPtr, TempLength); + memcpy((PVOID)((ULONG_PTR)Buffer + TempLength), Ccb->Data, CopyLength - TempLength); + Ccb->ReadPtr = (PVOID)((ULONG_PTR)Ccb->Data + CopyLength - TempLength); + } - /* Message mode */ - if (Ccb->ReadDataAvailable) - { - /* Truncate the message if the receive buffer is too small */ - CopyLength = min(Ccb->ReadDataAvailable, Length); - memcpy(Buffer, Ccb->Data, CopyLength); + Buffer = (PVOID)((ULONG_PTR)Buffer + CopyLength); + Length -= CopyLength; + Information += CopyLength; + + Ccb->ReadDataAvailable -= CopyLength; + Ccb->WriteQuotaAvailable += CopyLength; + } + + if (Length == 0) + { + if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) + { + KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE); + } + KeResetEvent(&Ccb->ReadEvent); + break; + } + } + else + { + DPRINT("Message mode\n"); + + /* Message mode */ + if (Ccb->ReadDataAvailable) + { + /* Truncate the message if the receive buffer is too small */ + CopyLength = min(Ccb->ReadDataAvailable, Length); + memcpy(Buffer, Ccb->Data, CopyLength); #ifndef NDEBUG - DPRINT("Length %d Buffer %x\n",CopyLength,Buffer); - HexDump((PUCHAR)Buffer, CopyLength); + DPRINT("Length %d Buffer %x\n",CopyLength,Buffer); + HexDump((PUCHAR)Buffer, CopyLength); #endif - Information = CopyLength; + Information = CopyLength; - if (Ccb->ReadDataAvailable > Length) - { - memmove(Ccb->Data, (PVOID)((ULONG_PTR)Ccb->Data + Length), - Ccb->ReadDataAvailable - Length); - Ccb->ReadDataAvailable -= Length; - Status = STATUS_MORE_ENTRIES; - } - else - { - KeResetEvent(&Ccb->ReadEvent); - if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) - { - KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE); - } - Ccb->ReadDataAvailable = 0; - Ccb->WriteQuotaAvailable = Ccb->MaxDataLength; - } - } + if (Ccb->ReadDataAvailable > Length) + { + memmove(Ccb->Data, (PVOID)((ULONG_PTR)Ccb->Data + Length), + Ccb->ReadDataAvailable - Length); + Ccb->ReadDataAvailable -= Length; + Status = STATUS_MORE_ENTRIES; + } + else + { + KeResetEvent(&Ccb->ReadEvent); + if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) + { + KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE); + } + Ccb->ReadDataAvailable = 0; + Ccb->WriteQuotaAvailable = Ccb->MaxDataLength; + } + } - if (Information > 0) - { - break; - } - } - } - Irp->IoStatus.Information = Information; - Irp->IoStatus.Status = Status; + if (Information > 0) + { + break; + } + } + } + Irp->IoStatus.Information = Information; + Irp->IoStatus.Status = Status; - ASSERT(IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL); + ASSERT(IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL); - if (IoIsOperationSynchronous(Irp)) - { - RemoveEntryList(&Context->ListEntry); - if (!IsListEmpty(&Ccb->ReadRequestListHead)) - { - Context = CONTAINING_RECORD(Ccb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry); - KeSetEvent(Context->WaitEvent, IO_NO_INCREMENT, FALSE); + if (IoIsOperationSynchronous(Irp)) + { + RemoveEntryList(&Context->ListEntry); + if (!IsListEmpty(&Ccb->ReadRequestListHead)) + { + Context = CONTAINING_RECORD(Ccb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry); + KeSetEvent(Context->WaitEvent, IO_NO_INCREMENT, FALSE); + } + ExReleaseFastMutex(&Ccb->DataListLock); + IoCompleteRequest(Irp, IO_NO_INCREMENT); + + DPRINT("NpfsRead done (Status %lx)\n", Status); + return Status; + } + else + { + if (IsOriginalRequest) + { + IsOriginalRequest = FALSE; + OriginalStatus = Status; + } + if (Status == STATUS_PENDING) + { + ExReleaseFastMutex(&Ccb->DataListLock); + DPRINT("NpfsRead done (Status %lx)\n", OriginalStatus); + return OriginalStatus; + } + RemoveEntryList(&Context->ListEntry); + IoCompleteRequest(Irp, IO_NO_INCREMENT); + if (IsListEmpty(&Ccb->ReadRequestListHead)) + { + ExReleaseFastMutex(&Ccb->DataListLock); + DPRINT("NpfsRead done (Status %lx)\n", OriginalStatus); + return OriginalStatus; + } + Context = CONTAINING_RECORD(Ccb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry); + Irp = CONTAINING_RECORD(Context, IRP, Tail.Overlay.DriverContext); + } } - ExReleaseFastMutex(&Ccb->DataListLock); - IoCompleteRequest(Irp, IO_NO_INCREMENT); - - DPRINT("NpfsRead done (Status %lx)\n", Status); - return Status; - } - else - { - if (IsOriginalRequest) - { - IsOriginalRequest = FALSE; - OriginalStatus = Status; - } - if (Status == STATUS_PENDING) - { - ExReleaseFastMutex(&Ccb->DataListLock); - DPRINT("NpfsRead done (Status %lx)\n", OriginalStatus); - return OriginalStatus; - } - RemoveEntryList(&Context->ListEntry); - IoCompleteRequest(Irp, IO_NO_INCREMENT); - if (IsListEmpty(&Ccb->ReadRequestListHead)) - { - ExReleaseFastMutex(&Ccb->DataListLock); - DPRINT("NpfsRead done (Status %lx)\n", OriginalStatus); - return OriginalStatus; - } - Context = CONTAINING_RECORD(Ccb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry); - Irp = CONTAINING_RECORD(Context, IRP, Tail.Overlay.DriverContext); - } - } done: - Irp->IoStatus.Status = Status; + Irp->IoStatus.Status = Status; - if (Status != STATUS_PENDING) - { - IoCompleteRequest(Irp, IO_NO_INCREMENT); - } - DPRINT("NpfsRead done (Status %lx)\n", Status); + if (Status != STATUS_PENDING) + { + IoCompleteRequest(Irp, IO_NO_INCREMENT); + } + DPRINT("NpfsRead done (Status %lx)\n", Status); - return Status; + return Status; } NTSTATUS STDCALL NpfsWrite(PDEVICE_OBJECT DeviceObject, - PIRP Irp) + PIRP Irp) { - PIO_STACK_LOCATION IoStack; - PFILE_OBJECT FileObject; - PNPFS_FCB Fcb = NULL; - PNPFS_CCB Ccb = NULL; - PNPFS_CCB ReaderCcb; - PUCHAR Buffer; - NTSTATUS Status = STATUS_SUCCESS; - ULONG Length; - ULONG Offset; - ULONG Information; - ULONG CopyLength; - ULONG TempLength; + PIO_STACK_LOCATION IoStack; + PFILE_OBJECT FileObject; + PNPFS_FCB Fcb = NULL; + PNPFS_CCB Ccb = NULL; + PNPFS_CCB ReaderCcb; + PUCHAR Buffer; + NTSTATUS Status = STATUS_SUCCESS; + ULONG Length; + ULONG Offset; + ULONG Information; + ULONG CopyLength; + ULONG TempLength; - DPRINT("NpfsWrite()\n"); + DPRINT("NpfsWrite()\n"); - IoStack = IoGetCurrentIrpStackLocation(Irp); - FileObject = IoStack->FileObject; - DPRINT("FileObject %p\n", FileObject); - DPRINT("Pipe name %wZ\n", &FileObject->FileName); + IoStack = IoGetCurrentIrpStackLocation(Irp); + FileObject = IoStack->FileObject; + DPRINT("FileObject %p\n", FileObject); + DPRINT("Pipe name %wZ\n", &FileObject->FileName); - Ccb = FileObject->FsContext2; - ReaderCcb = Ccb->OtherSide; - Fcb = Ccb->Fcb; + Ccb = FileObject->FsContext2; + ReaderCcb = Ccb->OtherSide; + Fcb = Ccb->Fcb; - Length = IoStack->Parameters.Write.Length; - Offset = IoStack->Parameters.Write.ByteOffset.u.LowPart; - Information = 0; + Length = IoStack->Parameters.Write.Length; + Offset = IoStack->Parameters.Write.ByteOffset.u.LowPart; + Information = 0; - if (Irp->MdlAddress == NULL) - { - DPRINT("Irp->MdlAddress == NULL\n"); - Status = STATUS_UNSUCCESSFUL; - Length = 0; - goto done; - } + if (Irp->MdlAddress == NULL) + { + DPRINT("Irp->MdlAddress == NULL\n"); + Status = STATUS_UNSUCCESSFUL; + Length = 0; + goto done; + } - if (ReaderCcb == NULL) - { - DPRINT("Pipe is NOT connected!\n"); - if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE) - Status = STATUS_PIPE_LISTENING; - else if (Ccb->PipeState == FILE_PIPE_DISCONNECTED_STATE) - Status = STATUS_PIPE_DISCONNECTED; - else - Status = STATUS_UNSUCCESSFUL; - Length = 0; - goto done; - } + if (ReaderCcb == NULL) + { + DPRINT("Pipe is NOT connected!\n"); + if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE) + Status = STATUS_PIPE_LISTENING; + else if (Ccb->PipeState == FILE_PIPE_DISCONNECTED_STATE) + Status = STATUS_PIPE_DISCONNECTED; + else + Status = STATUS_UNSUCCESSFUL; + Length = 0; + goto done; + } - if (ReaderCcb->Data == NULL) - { - DPRINT("Pipe is NOT writable!\n"); - Status = STATUS_UNSUCCESSFUL; - Length = 0; - goto done; - } + if (ReaderCcb->Data == NULL) + { + DPRINT("Pipe is NOT writable!\n"); + Status = STATUS_UNSUCCESSFUL; + Length = 0; + goto done; + } - Status = STATUS_SUCCESS; - Buffer = MmGetSystemAddressForMdl (Irp->MdlAddress); + Status = STATUS_SUCCESS; + Buffer = MmGetSystemAddressForMdl (Irp->MdlAddress); - ExAcquireFastMutex(&ReaderCcb->DataListLock); + ExAcquireFastMutex(&ReaderCcb->DataListLock); #ifndef NDEBUG - DPRINT("Length %d Buffer %x Offset %x\n",Length,Buffer,Offset); - HexDump(Buffer, Length); + DPRINT("Length %d Buffer %x Offset %x\n",Length,Buffer,Offset); + HexDump(Buffer, Length); #endif - while(1) - { - if (ReaderCcb->WriteQuotaAvailable == 0) + while(1) { - KeSetEvent(&ReaderCcb->ReadEvent, IO_NO_INCREMENT, FALSE); - if (Ccb->PipeState != FILE_PIPE_CONNECTED_STATE) - { - Status = STATUS_PIPE_BROKEN; - ExReleaseFastMutex(&ReaderCcb->DataListLock); - goto done; - } - ExReleaseFastMutex(&ReaderCcb->DataListLock); - - DPRINT("Waiting for buffer space (%S)\n", Fcb->PipeName.Buffer); - Status = KeWaitForSingleObject(&Ccb->WriteEvent, - UserRequest, - KernelMode, - FALSE, - NULL); - DPRINT("Finished waiting (%S)! Status: %x\n", Fcb->PipeName.Buffer, Status); - - ExAcquireFastMutex(&ReaderCcb->DataListLock); - /* - * It's possible that the event was signaled because the - * other side of pipe was closed. - */ - if (Ccb->PipeState != FILE_PIPE_CONNECTED_STATE) - { - DPRINT("PipeState: %x\n", Ccb->PipeState); - Status = STATUS_PIPE_BROKEN; - ExReleaseFastMutex(&ReaderCcb->DataListLock); - goto done; - } - } - - if (Fcb->WriteMode == FILE_PIPE_BYTE_STREAM_MODE) - { - DPRINT("Byte stream mode\n"); - while (Length > 0 && ReaderCcb->WriteQuotaAvailable > 0) - { - CopyLength = min(Length, ReaderCcb->WriteQuotaAvailable); - if ((ULONG_PTR)ReaderCcb->WritePtr + CopyLength <= (ULONG_PTR)ReaderCcb->Data + ReaderCcb->MaxDataLength) + if (ReaderCcb->WriteQuotaAvailable == 0) { - memcpy(ReaderCcb->WritePtr, Buffer, CopyLength); - ReaderCcb->WritePtr = (PVOID)((ULONG_PTR)ReaderCcb->WritePtr + CopyLength); - if ((ULONG_PTR)ReaderCcb->WritePtr == (ULONG_PTR)ReaderCcb->Data + ReaderCcb->MaxDataLength) - { - ReaderCcb->WritePtr = ReaderCcb->Data; - } - } - else - { - TempLength = (ULONG)((ULONG_PTR)ReaderCcb->Data + ReaderCcb->MaxDataLength - (ULONG_PTR)ReaderCcb->WritePtr); - memcpy(ReaderCcb->WritePtr, Buffer, TempLength); - memcpy(ReaderCcb->Data, Buffer + TempLength, CopyLength - TempLength); - ReaderCcb->WritePtr = (PVOID)((ULONG_PTR)ReaderCcb->Data + CopyLength - TempLength); + KeSetEvent(&ReaderCcb->ReadEvent, IO_NO_INCREMENT, FALSE); + if (Ccb->PipeState != FILE_PIPE_CONNECTED_STATE) + { + Status = STATUS_PIPE_BROKEN; + ExReleaseFastMutex(&ReaderCcb->DataListLock); + goto done; + } + ExReleaseFastMutex(&ReaderCcb->DataListLock); + + DPRINT("Waiting for buffer space (%S)\n", Fcb->PipeName.Buffer); + Status = KeWaitForSingleObject(&Ccb->WriteEvent, + UserRequest, + KernelMode, + FALSE, + NULL); + DPRINT("Finished waiting (%S)! Status: %x\n", Fcb->PipeName.Buffer, Status); + + ExAcquireFastMutex(&ReaderCcb->DataListLock); + /* + * It's possible that the event was signaled because the + * other side of pipe was closed. + */ + if (Ccb->PipeState != FILE_PIPE_CONNECTED_STATE) + { + DPRINT("PipeState: %x\n", Ccb->PipeState); + Status = STATUS_PIPE_BROKEN; + ExReleaseFastMutex(&ReaderCcb->DataListLock); + goto done; + } } - Buffer += CopyLength; - Length -= CopyLength; - Information += CopyLength; + if (Fcb->WriteMode == FILE_PIPE_BYTE_STREAM_MODE) + { + DPRINT("Byte stream mode\n"); + while (Length > 0 && ReaderCcb->WriteQuotaAvailable > 0) + { + CopyLength = min(Length, ReaderCcb->WriteQuotaAvailable); + if ((ULONG_PTR)ReaderCcb->WritePtr + CopyLength <= (ULONG_PTR)ReaderCcb->Data + ReaderCcb->MaxDataLength) + { + memcpy(ReaderCcb->WritePtr, Buffer, CopyLength); + ReaderCcb->WritePtr = (PVOID)((ULONG_PTR)ReaderCcb->WritePtr + CopyLength); + if ((ULONG_PTR)ReaderCcb->WritePtr == (ULONG_PTR)ReaderCcb->Data + ReaderCcb->MaxDataLength) + { + ReaderCcb->WritePtr = ReaderCcb->Data; + } + } + else + { + TempLength = (ULONG)((ULONG_PTR)ReaderCcb->Data + ReaderCcb->MaxDataLength - (ULONG_PTR)ReaderCcb->WritePtr); + memcpy(ReaderCcb->WritePtr, Buffer, TempLength); + memcpy(ReaderCcb->Data, Buffer + TempLength, CopyLength - TempLength); + ReaderCcb->WritePtr = (PVOID)((ULONG_PTR)ReaderCcb->Data + CopyLength - TempLength); + } - ReaderCcb->ReadDataAvailable += CopyLength; - ReaderCcb->WriteQuotaAvailable -= CopyLength; - } + Buffer += CopyLength; + Length -= CopyLength; + Information += CopyLength; - if (Length == 0) - { - KeSetEvent(&ReaderCcb->ReadEvent, IO_NO_INCREMENT, FALSE); - KeResetEvent(&Ccb->WriteEvent); - break; - } + ReaderCcb->ReadDataAvailable += CopyLength; + ReaderCcb->WriteQuotaAvailable -= CopyLength; + } + + if (Length == 0) + { + KeSetEvent(&ReaderCcb->ReadEvent, IO_NO_INCREMENT, FALSE); + KeResetEvent(&Ccb->WriteEvent); + break; + } + } + else + { + DPRINT("Message mode\n"); + if (Length > 0) + { + CopyLength = min(Length, ReaderCcb->WriteQuotaAvailable); + memcpy(ReaderCcb->Data, Buffer, CopyLength); + + Information = CopyLength; + ReaderCcb->ReadDataAvailable = CopyLength; + ReaderCcb->WriteQuotaAvailable = 0; + } + + if (Information > 0) + { + KeSetEvent(&ReaderCcb->ReadEvent, IO_NO_INCREMENT, FALSE); + KeResetEvent(&Ccb->WriteEvent); + break; + } + } } - else - { - DPRINT("Message mode\n"); - if (Length > 0) - { - CopyLength = min(Length, ReaderCcb->WriteQuotaAvailable); - memcpy(ReaderCcb->Data, Buffer, CopyLength); - Information = CopyLength; - ReaderCcb->ReadDataAvailable = CopyLength; - ReaderCcb->WriteQuotaAvailable = 0; - } - - if (Information > 0) - { - KeSetEvent(&ReaderCcb->ReadEvent, IO_NO_INCREMENT, FALSE); - KeResetEvent(&Ccb->WriteEvent); - break; - } - } - } - - ExReleaseFastMutex(&ReaderCcb->DataListLock); + ExReleaseFastMutex(&ReaderCcb->DataListLock); done: - Irp->IoStatus.Status = Status; - Irp->IoStatus.Information = Information; + Irp->IoStatus.Status = Status; + Irp->IoStatus.Information = Information; - IoCompleteRequest(Irp, IO_NO_INCREMENT); + IoCompleteRequest(Irp, IO_NO_INCREMENT); - DPRINT("NpfsWrite done (Status %lx)\n", Status); + DPRINT("NpfsWrite done (Status %lx)\n", Status); - return Status; + return Status; } /* EOF */ diff --git a/reactos/drivers/filesystems/npfs/volume.c b/reactos/drivers/filesystems/npfs/volume.c index e0a8eb78674..8276cb055ee 100644 --- a/reactos/drivers/filesystems/npfs/volume.c +++ b/reactos/drivers/filesystems/npfs/volume.c @@ -1,10 +1,10 @@ /* - * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel - * FILE: drivers/fs/npfs/volume.c - * PURPOSE: Named pipe filesystem - * PROGRAMMER: Eric Kohl - */ +* COPYRIGHT: See COPYING in the top level directory +* PROJECT: ReactOS kernel +* FILE: drivers/fs/npfs/volume.c +* PURPOSE: Named pipe filesystem +* PROGRAMMER: Eric Kohl +*/ /* INCLUDES *****************************************************************/ @@ -17,99 +17,99 @@ static NTSTATUS NpfsQueryFsDeviceInformation(PFILE_FS_DEVICE_INFORMATION FsDeviceInfo, - PULONG BufferLength) + PULONG BufferLength) { - DPRINT("NpfsQueryFsDeviceInformation()\n"); - DPRINT("FsDeviceInfo = %p\n", FsDeviceInfo); + DPRINT("NpfsQueryFsDeviceInformation()\n"); + DPRINT("FsDeviceInfo = %p\n", FsDeviceInfo); - if (*BufferLength < sizeof(FILE_FS_DEVICE_INFORMATION)) - return STATUS_BUFFER_OVERFLOW; + if (*BufferLength < sizeof(FILE_FS_DEVICE_INFORMATION)) + return STATUS_BUFFER_OVERFLOW; - FsDeviceInfo->DeviceType = FILE_DEVICE_NAMED_PIPE; - FsDeviceInfo->Characteristics = 0; + FsDeviceInfo->DeviceType = FILE_DEVICE_NAMED_PIPE; + FsDeviceInfo->Characteristics = 0; - *BufferLength -= sizeof(FILE_FS_DEVICE_INFORMATION); + *BufferLength -= sizeof(FILE_FS_DEVICE_INFORMATION); - DPRINT("NpfsQueryFsDeviceInformation() finished.\n"); + DPRINT("NpfsQueryFsDeviceInformation() finished.\n"); - return STATUS_SUCCESS; + return STATUS_SUCCESS; } static NTSTATUS NpfsQueryFsAttributeInformation(PFILE_FS_ATTRIBUTE_INFORMATION FsAttributeInfo, - PULONG BufferLength) + PULONG BufferLength) { - DPRINT("NpfsQueryFsAttributeInformation() called.\n"); - DPRINT("FsAttributeInfo = %p\n", FsAttributeInfo); + DPRINT("NpfsQueryFsAttributeInformation() called.\n"); + DPRINT("FsAttributeInfo = %p\n", FsAttributeInfo); - if (*BufferLength < sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + 8) - return STATUS_BUFFER_OVERFLOW; + if (*BufferLength < sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + 8) + return STATUS_BUFFER_OVERFLOW; - FsAttributeInfo->FileSystemAttributes = FILE_CASE_PRESERVED_NAMES; - FsAttributeInfo->MaximumComponentNameLength = 255; - FsAttributeInfo->FileSystemNameLength = 8; - wcscpy(FsAttributeInfo->FileSystemName, - L"NPFS"); + FsAttributeInfo->FileSystemAttributes = FILE_CASE_PRESERVED_NAMES; + FsAttributeInfo->MaximumComponentNameLength = 255; + FsAttributeInfo->FileSystemNameLength = 8; + wcscpy(FsAttributeInfo->FileSystemName, + L"NPFS"); - DPRINT("NpfsQueryFsAttributeInformation() finished.\n"); - *BufferLength -= (sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + 8); + DPRINT("NpfsQueryFsAttributeInformation() finished.\n"); + *BufferLength -= (sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + 8); - return STATUS_SUCCESS; + return STATUS_SUCCESS; } NTSTATUS STDCALL NpfsQueryVolumeInformation(PDEVICE_OBJECT DeviceObject, - PIRP Irp) + PIRP Irp) { - PIO_STACK_LOCATION Stack; - FS_INFORMATION_CLASS FsInformationClass; - NTSTATUS Status = STATUS_SUCCESS; - PVOID SystemBuffer; - ULONG BufferLength; + PIO_STACK_LOCATION Stack; + FS_INFORMATION_CLASS FsInformationClass; + NTSTATUS Status = STATUS_SUCCESS; + PVOID SystemBuffer; + ULONG BufferLength; - /* PRECONDITION */ - ASSERT(DeviceObject != NULL); - ASSERT(Irp != NULL); + /* PRECONDITION */ + ASSERT(DeviceObject != NULL); + ASSERT(Irp != NULL); - DPRINT("NpfsQueryVolumeInformation(DeviceObject %x, Irp %x)\n", - DeviceObject, - Irp); + DPRINT("NpfsQueryVolumeInformation(DeviceObject %x, Irp %x)\n", + DeviceObject, + Irp); - Stack = IoGetCurrentIrpStackLocation(Irp); - FsInformationClass = Stack->Parameters.QueryVolume.FsInformationClass; - BufferLength = Stack->Parameters.QueryVolume.Length; - SystemBuffer = Irp->AssociatedIrp.SystemBuffer; + Stack = IoGetCurrentIrpStackLocation(Irp); + FsInformationClass = Stack->Parameters.QueryVolume.FsInformationClass; + BufferLength = Stack->Parameters.QueryVolume.Length; + SystemBuffer = Irp->AssociatedIrp.SystemBuffer; - DPRINT("FsInformationClass %d\n", FsInformationClass); - DPRINT("SystemBuffer %x\n", SystemBuffer); + DPRINT("FsInformationClass %d\n", FsInformationClass); + DPRINT("SystemBuffer %x\n", SystemBuffer); - switch (FsInformationClass) - { - case FileFsDeviceInformation: - Status = NpfsQueryFsDeviceInformation(SystemBuffer, - &BufferLength); - break; + switch (FsInformationClass) + { + case FileFsDeviceInformation: + Status = NpfsQueryFsDeviceInformation(SystemBuffer, + &BufferLength); + break; - case FileFsAttributeInformation: - Status = NpfsQueryFsAttributeInformation(SystemBuffer, - &BufferLength); - break; + case FileFsAttributeInformation: + Status = NpfsQueryFsAttributeInformation(SystemBuffer, + &BufferLength); + break; - default: - Status = STATUS_NOT_SUPPORTED; - } + default: + Status = STATUS_NOT_SUPPORTED; + } - Irp->IoStatus.Status = Status; - if (NT_SUCCESS(Status)) - Irp->IoStatus.Information = Stack->Parameters.QueryVolume.Length - BufferLength; - else - Irp->IoStatus.Information = 0; - IoCompleteRequest(Irp, - IO_NO_INCREMENT); + Irp->IoStatus.Status = Status; + if (NT_SUCCESS(Status)) + Irp->IoStatus.Information = Stack->Parameters.QueryVolume.Length - BufferLength; + else + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, + IO_NO_INCREMENT); - return Status; + return Status; } /* EOF */