diff --git a/reactos/drivers/filesystems/npfs/create.c b/reactos/drivers/filesystems/npfs/create.c
index 43cb448d24c..51a438d87e3 100644
--- a/reactos/drivers/filesystems/npfs/create.c
+++ b/reactos/drivers/filesystems/npfs/create.c
@@ -17,760 +17,760 @@
 
 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)
-		{
-			DPRINT("<%wZ> = <%wZ>\n", PipeName, &Fcb->PipeName);
-			return Fcb;
-		}
+    CurrentEntry = DeviceExt->PipeListHead.Flink;
+    while (CurrentEntry != &DeviceExt->PipeListHead)
+    {
+        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)
-		{
-			DPRINT("Server found! CCB %p\n", Waiter->Ccb);
+    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)
+        {
+            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)
-		{
-			DPRINT("Server found! CCB %p\n", Waiter->Ccb);
+    CurrentEntry = Fcb->WaiterListHead.Flink;
+    while (CurrentEntry != &Fcb->WaiterListHead)
+    {
+        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;
-		}
-		CurrentEntry = CurrentEntry->Flink;
-	}
+            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;
+    }
 }
 
 
 NTSTATUS NTAPI
 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_OBJECT_PATH_NOT_FOUND;
-				IoCompleteRequest(Irp, IO_NO_INCREMENT);
-				return STATUS_OBJECT_PATH_NOT_FOUND;
-			}
-		}
-		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_OBJECT_PATH_NOT_FOUND;
+                IoCompleteRequest(Irp, IO_NO_INCREMENT);
+                return STATUS_OBJECT_PATH_NOT_FOUND;
+            }
+        }
+        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 NTAPI
 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;
-		IoCompleteRequest(Irp, IO_NO_INCREMENT);
-		return 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 = 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);
+    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);
+    /*
+    * 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_INSTANCE_NOT_AVAILABLE;
-			IoCompleteRequest(Irp, IO_NO_INCREMENT);
-			return STATUS_INSTANCE_NOT_AVAILABLE;
-		}
+        if (Fcb->CurrentInstances >= Fcb->MaximumInstances)
+        {
+            DPRINT("Out of instances.\n");
+            ExFreePool(Ccb);
+            Irp->IoStatus.Status = STATUS_INSTANCE_NOT_AVAILABLE;
+            IoCompleteRequest(Irp, IO_NO_INCREMENT);
+            return STATUS_INSTANCE_NOT_AVAILABLE;
+        }
 
-		if (Fcb->MaximumInstances != Buffer->MaximumInstances ||
-			Fcb->TimeOut.QuadPart != Buffer->DefaultTimeout.QuadPart ||
-			Fcb->PipeType != Buffer->NamedPipeType)
-		{
-			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;
-		}
+        if (Fcb->MaximumInstances != Buffer->MaximumInstances ||
+            Fcb->TimeOut.QuadPart != Buffer->DefaultTimeout.QuadPart ||
+            Fcb->PipeType != Buffer->NamedPipeType)
+        {
+            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;
-		}
+        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);
+        RtlCopyUnicodeString(&Fcb->PipeName, &FileObject->FileName);
 
-		InitializeListHead(&Fcb->ServerCcbListHead);
-		InitializeListHead(&Fcb->ClientCcbListHead);
-		InitializeListHead(&Fcb->WaiterListHead);
-		KeInitializeMutex(&Fcb->CcbListLock, 0);
+        InitializeListHead(&Fcb->ServerCcbListHead);
+        InitializeListHead(&Fcb->ClientCcbListHead);
+        InitializeListHead(&Fcb->WaiterListHead);
+        KeInitializeMutex(&Fcb->CcbListLock, 0);
 
-		Fcb->PipeType = Buffer->NamedPipeType;
-		Fcb->ServerReadMode = Buffer->ReadMode;
-		/* MSDN documentation reads that clients always start off in byte mode */
-		Fcb->ClientReadMode = FILE_PIPE_BYTE_STREAM_MODE;
+        Fcb->PipeType = Buffer->NamedPipeType;
+        Fcb->ServerReadMode = Buffer->ReadMode;
+        /* MSDN documentation reads that clients always start off in byte mode */
+        Fcb->ClientReadMode = FILE_PIPE_BYTE_STREAM_MODE;
 
-		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;
-		}
+        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;
-		}
+        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);
-	}
+        InsertTailList(&DeviceExt->PipeListHead, &Fcb->PipeListEntry);
+        KeUnlockMutex(&DeviceExt->PipeListLock);
+    }
 
-	if (Fcb->InboundQuota)
-	{
-		Ccb->Data = ExAllocatePool(PagedPool, Fcb->InboundQuota);
-		if (Ccb->Data == NULL)
-		{
-			ExFreePool(Ccb);
+    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);
-			}
+            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;
-	}
+            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);
+    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++;
+    Fcb->CurrentInstances++;
 
-	Ccb->Fcb = Fcb;
-	Ccb->PipeEnd = FILE_PIPE_SERVER_END;
-	Ccb->PipeState = FILE_PIPE_LISTENING_STATE;
-	Ccb->OtherSide = NULL;
+    Ccb->Fcb = Fcb;
+    Ccb->PipeEnd = FILE_PIPE_SERVER_END;
+    Ccb->PipeState = FILE_PIPE_LISTENING_STATE;
+    Ccb->OtherSide = NULL;
 
-	DPRINT("CCB: %p\n", Ccb);
+    DPRINT("CCB: %p\n", Ccb);
 
-	KeInitializeEvent(&Ccb->ConnectEvent, SynchronizationEvent, FALSE);
-	KeInitializeEvent(&Ccb->ReadEvent, SynchronizationEvent, FALSE);
-	KeInitializeEvent(&Ccb->WriteEvent, SynchronizationEvent, FALSE);
+    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);
+    KeLockMutex(&Fcb->CcbListLock);
+    InsertTailList(&Fcb->ServerCcbListHead, &Ccb->CcbListEntry);
+    KeUnlockMutex(&Fcb->CcbListLock);
 
-	FileObject->FsContext = Fcb;
-	FileObject->FsContext2 = Ccb;
-	FileObject->Flags |= FO_NAMED_PIPE;
+    FileObject->FsContext = Fcb;
+    FileObject->FsContext2 = Ccb;
+    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 NTAPI
 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 NTAPI
 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 %p\n", Ccb);
-	Fcb = Ccb->Fcb;
+    DPRINT("CCB %p\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");
+    }
 
-	/* Disconnect the pipes */
-	if (Ccb->OtherSide) Ccb->OtherSide->OtherSide = NULL;
-	if (Ccb) Ccb->OtherSide = NULL;
+    /* Disconnect the pipes */
+    if (Ccb->OtherSide) Ccb->OtherSide->OtherSide = NULL;
+    if (Ccb) Ccb->OtherSide = NULL;
 
-	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 a757e915782..18c53414d64 100644
--- a/reactos/drivers/filesystems/npfs/finfo.c
+++ b/reactos/drivers/filesystems/npfs/finfo.c
@@ -18,287 +18,286 @@
 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;
 
-	if ((Fcb->PipeType == FILE_PIPE_BYTE_STREAM_TYPE) && (Request->ReadMode == FILE_PIPE_MESSAGE_MODE))
-	{
-		DPRINT("Cannot change readmode to message type on a byte type pipe!\n");
-		return STATUS_ACCESS_DENIED;
-	}
-	
-	/* Set Pipe Data */
-	if (Ccb->PipeEnd == FILE_PIPE_CLIENT_END)
-	{
-		Fcb->ClientReadMode = Request->ReadMode;
-	}
-	else 
-	{
-		Fcb->ServerReadMode = Request->ReadMode;
-	}
+    if ((Fcb->PipeType == FILE_PIPE_BYTE_STREAM_TYPE) && (Request->ReadMode == FILE_PIPE_MESSAGE_MODE))
+    {
+        DPRINT("Cannot change readmode to message type on a byte type pipe!\n");
+        return STATUS_ACCESS_DENIED;
+    }
 
-	Fcb->CompletionMode =  Request->CompletionMode;
+    /* Set Pipe Data */
+    if (Ccb->PipeEnd == FILE_PIPE_CLIENT_END)
+    {
+        Fcb->ClientReadMode = Request->ReadMode;
+    }
+    else 
+    {
+        Fcb->ServerReadMode = Request->ReadMode;
+    }
 
-	/* Return Success */
-	return STATUS_SUCCESS;
+    Fcb->CompletionMode =  Request->CompletionMode;
+
+    /* 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;
-	ULONG ConnectionSideReadMode;
-	DPRINT("NpfsQueryPipeInformation()\n");
+    PNPFS_FCB Fcb;
+    ULONG ConnectionSideReadMode;
+    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));
 
-	if (Ccb->PipeEnd == FILE_PIPE_CLIENT_END) ConnectionSideReadMode=Ccb->Fcb->ClientReadMode;
-	else ConnectionSideReadMode = Ccb->Fcb->ServerReadMode;
+    if (Ccb->PipeEnd == FILE_PIPE_CLIENT_END) ConnectionSideReadMode=Ccb->Fcb->ClientReadMode;
+    else ConnectionSideReadMode = Ccb->Fcb->ServerReadMode;
 
-	/* Return Info */
-	Info->CompletionMode = Fcb->CompletionMode;
-	Info->ReadMode = ConnectionSideReadMode;
+    /* Return Info */
+    Info->CompletionMode = Fcb->CompletionMode;
+    Info->ReadMode = ConnectionSideReadMode;
 
-	/* 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,
-		sizeof(FILE_PIPE_LOCAL_INFORMATION));
+    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 NTAPI
 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 NTAPI
 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 da41d1290ae..75b6db5ecef 100644
--- a/reactos/drivers/filesystems/npfs/fsctrl.c
+++ b/reactos/drivers/filesystems/npfs/fsctrl.c
@@ -20,326 +20,326 @@
 static DRIVER_CANCEL NpfsListeningCancelRoutine;
 static VOID NTAPI
 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_CONNECTED_STATE)
+    {
+        KeResetEvent(&Ccb->ConnectEvent);
+        return STATUS_PIPE_CONNECTED;
+    }
 
-	if (Ccb->PipeState == FILE_PIPE_CLOSING_STATE)
-		return STATUS_PIPE_CLOSING;
+    if (Ccb->PipeState == FILE_PIPE_CLOSING_STATE)
+        return STATUS_PIPE_CLOSING;
 
-	DPRINT("Waiting for connection...\n");
+    DPRINT("Waiting for connection...\n");
 
-	Fcb = Ccb->Fcb;
-	IoStack = IoGetCurrentIrpStackLocation(Irp);
-	FileObject = IoStack->FileObject;
-	Flags = FileObject->Flags;
+    Fcb = Ccb->Fcb;
+    IoStack = IoGetCurrentIrpStackLocation(Irp);
+    FileObject = IoStack->FileObject;
+    Flags = FileObject->Flags;
 
-	/* search for a listening client fcb */
-	KeLockMutex(&Fcb->CcbListLock);
+    /* 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);
+    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 (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,
-			Irp->RequestorMode,
-			FALSE,
-			NULL);
-	}
+    if (Flags & FO_SYNCHRONOUS_IO)
+    {
+        KeWaitForSingleObject(&Ccb->ConnectEvent,
+            UserRequest,
+            Irp->RequestorMode,
+            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;
-	LARGE_INTEGER TimeOut;
+    PLIST_ENTRY current_entry;
+    PNPFS_FCB Fcb;
+    PNPFS_CCB ServerCcb;
+    PFILE_PIPE_WAIT_FOR_BUFFER WaitPipe;
+    NTSTATUS Status;
+    LARGE_INTEGER TimeOut;
 
-	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;
-	}
+    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);
+    /* 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)
-		{
-			/* found a listening server CCB */
-			DPRINT("Listening server CCB found -- connecting\n");
+        if (ServerCcb->PipeState == FILE_PIPE_LISTENING_STATE)
+        {
+            /* found a listening server CCB */
+            DPRINT("Listening server CCB found -- connecting\n");
 
-			return STATUS_SUCCESS;
-		}
+            return STATUS_SUCCESS;
+        }
 
-		current_entry = current_entry->Flink;
-	}
+        current_entry = current_entry->Flink;
+    }
 
-	/* No listening server fcb found */
+    /* No listening server fcb found */
 
-	/* If no timeout specified, use the default one */
-	if (WaitPipe->TimeoutSpecified)
-		TimeOut = WaitPipe->Timeout;
-	else
-		TimeOut = Fcb->TimeOut;
+    /* If no timeout specified, use the default one */
+    if (WaitPipe->TimeoutSpecified)
+        TimeOut = WaitPipe->Timeout;
+    else
+        TimeOut = Fcb->TimeOut;
 
-	/* Wait for one */
-	Status = KeWaitForSingleObject(&Ccb->ConnectEvent,
-		UserRequest,
-		KernelMode,
-		FALSE,
-		&TimeOut);
+    /* Wait for one */
+    Status = KeWaitForSingleObject(&Ccb->ConnectEvent,
+        UserRequest,
+        KernelMode,
+        FALSE,
+        &TimeOut);
 
-	DPRINT("KeWaitForSingleObject() returned (Status %lx)\n", Status);
+    DPRINT("KeWaitForSingleObject() returned (Status %lx)\n", Status);
 
-	return Status;
+    return Status;
 }
 
 
@@ -362,243 +362,243 @@ NpfsWaitPipe(PIRP Irp,
 */
 static NTSTATUS
 NpfsPeekPipe(PIRP Irp,
-			 PIO_STACK_LOCATION IoStack)
+             PIO_STACK_LOCATION IoStack)
 {
-	ULONG OutputBufferLength;
-	ULONG ReturnLength = 0;
-	PFILE_PIPE_PEEK_BUFFER Reply;
-	PNPFS_FCB Fcb;
-	PNPFS_CCB Ccb;
-	NTSTATUS Status;
-	ULONG MessageCount = 0;
-	ULONG MessageLength;
-	ULONG ReadDataAvailable;
-	PVOID BufferPtr;
+    ULONG OutputBufferLength;
+    ULONG ReturnLength = 0;
+    PFILE_PIPE_PEEK_BUFFER Reply;
+    PNPFS_FCB Fcb;
+    PNPFS_CCB Ccb;
+    NTSTATUS Status;
+    ULONG MessageCount = 0;
+    ULONG MessageLength;
+    ULONG ReadDataAvailable;
+    PVOID BufferPtr;
 
-	DPRINT("NpfsPeekPipe\n");
+    DPRINT("NpfsPeekPipe\n");
 
-	OutputBufferLength = IoStack->Parameters.DeviceIoControl.OutputBufferLength;
-	DPRINT("OutputBufferLength: %lu\n", OutputBufferLength);
+    OutputBufferLength = IoStack->Parameters.DeviceIoControl.OutputBufferLength;
+    DPRINT("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);
 
-	ExAcquireFastMutex(&Ccb->DataListLock);
-	BufferPtr = Ccb->ReadPtr;
-	DPRINT("BufferPtr = %x\n", BufferPtr);
-	if (Ccb->Fcb->PipeType == FILE_PIPE_BYTE_STREAM_TYPE)
-	{
-		DPRINT("Byte Stream Mode\n");
-		Reply->MessageLength = Ccb->ReadDataAvailable;
-		DPRINT("Reply->MessageLength  %lu\n",Reply->MessageLength );
-		MessageCount = 1;
+    ExAcquireFastMutex(&Ccb->DataListLock);
+    BufferPtr = Ccb->ReadPtr;
+    DPRINT("BufferPtr = %x\n", BufferPtr);
+    if (Ccb->Fcb->PipeType == FILE_PIPE_BYTE_STREAM_TYPE)
+    {
+        DPRINT("Byte Stream Mode\n");
+        Reply->MessageLength = Ccb->ReadDataAvailable;
+        DPRINT("Reply->MessageLength  %lu\n",Reply->MessageLength );
+        MessageCount = 1;
 
-		if (Reply->Data[0] && (OutputBufferLength >= Ccb->ReadDataAvailable + FIELD_OFFSET(FILE_PIPE_PEEK_BUFFER, Data[0])))
-		{
-			ReturnLength = Ccb->ReadDataAvailable;
-			memcpy(&Reply->Data[0], (PVOID)BufferPtr, Ccb->ReadDataAvailable);
-		}
-	}
-	else
-	{
-		DPRINT("Message Mode\n");
-		ReadDataAvailable=Ccb->ReadDataAvailable;
+        if (Reply->Data[0] && (OutputBufferLength >= Ccb->ReadDataAvailable + FIELD_OFFSET(FILE_PIPE_PEEK_BUFFER, Data[0])))
+        {
+            ReturnLength = Ccb->ReadDataAvailable;
+            memcpy(&Reply->Data[0], (PVOID)BufferPtr, Ccb->ReadDataAvailable);
+        }
+    }
+    else
+    {
+        DPRINT("Message Mode\n");
+        ReadDataAvailable=Ccb->ReadDataAvailable;
 
-		if (ReadDataAvailable > 0)
-		{
-			memcpy(&Reply->MessageLength, BufferPtr, sizeof(ULONG));
+        if (ReadDataAvailable > 0)
+        {
+            memcpy(&Reply->MessageLength, BufferPtr, sizeof(ULONG));
 
-			while ((ReadDataAvailable > 0) && (BufferPtr < Ccb->WritePtr))
-			{
-				memcpy(&MessageLength, BufferPtr, sizeof(MessageLength));
+            while ((ReadDataAvailable > 0) && (BufferPtr < Ccb->WritePtr))
+            {
+                memcpy(&MessageLength, BufferPtr, sizeof(MessageLength));
 
-				ASSERT(MessageLength > 0);
+                ASSERT(MessageLength > 0);
 
-				DPRINT("MessageLength = %lu\n",MessageLength);
-				ReadDataAvailable -= MessageLength;
-				MessageCount++;
+                DPRINT("MessageLength = %lu\n",MessageLength);
+                ReadDataAvailable -= MessageLength;
+                MessageCount++;
 
-				/* If its the first message, copy the Message if the size of buffer is large enough */
-				if (MessageCount==1)
-				{	
-					if ((Reply->Data[0])
-						&& (OutputBufferLength >= (MessageLength + FIELD_OFFSET(FILE_PIPE_PEEK_BUFFER, Data[0]))))
-					{							
-						memcpy(&Reply->Data[0], (PVOID)((ULONG_PTR)BufferPtr + sizeof(MessageLength)), MessageLength);
-						ReturnLength = MessageLength;
-					}
-				}
+                /* If its the first message, copy the Message if the size of buffer is large enough */
+                if (MessageCount==1)
+                {
+                    if ((Reply->Data[0])
+                        && (OutputBufferLength >= (MessageLength + FIELD_OFFSET(FILE_PIPE_PEEK_BUFFER, Data[0]))))
+                    {
+                        memcpy(&Reply->Data[0], (PVOID)((ULONG_PTR)BufferPtr + sizeof(MessageLength)), MessageLength);
+                        ReturnLength = MessageLength;
+                    }
+                }
 
-				BufferPtr =(PVOID)((ULONG_PTR)BufferPtr + MessageLength + sizeof(MessageLength));
-				DPRINT("BufferPtr = %x\n", BufferPtr);
-				DPRINT("ReadDataAvailable: %lu\n", ReadDataAvailable);
-			}
+                BufferPtr =(PVOID)((ULONG_PTR)BufferPtr + MessageLength + sizeof(MessageLength));
+                DPRINT("BufferPtr = %x\n", BufferPtr);
+                DPRINT("ReadDataAvailable: %lu\n", ReadDataAvailable);
+            }
 
-			if (ReadDataAvailable != 0)
-			{
-				DPRINT1("Possible memory corruption.\n");
-				ASSERT(FALSE);
-			}
-		}
-	}
-	ExReleaseFastMutex(&Ccb->DataListLock);
+            if (ReadDataAvailable != 0)
+            {
+                DPRINT1("Possible memory corruption.\n");
+                ASSERT(FALSE);
+            }
+        }
+    }
+    ExReleaseFastMutex(&Ccb->DataListLock);
 
-	Reply->NumberOfMessages = MessageCount;
+    Reply->NumberOfMessages = MessageCount;
 
-	Irp->IoStatus.Information = ReturnLength + FIELD_OFFSET(FILE_PIPE_PEEK_BUFFER, Data[0]);
-	Irp->IoStatus.Status = STATUS_SUCCESS;
+    Irp->IoStatus.Information = ReturnLength + FIELD_OFFSET(FILE_PIPE_PEEK_BUFFER, Data[0]);
+    Irp->IoStatus.Status = STATUS_SUCCESS;
 
-	Status = STATUS_SUCCESS;
+    Status = STATUS_SUCCESS;
 
-	DPRINT("NpfsPeekPipe done\n");
+    DPRINT("NpfsPeekPipe done\n");
 
-	return Status;
+    return Status;
 }
 
 
 NTSTATUS NTAPI
 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 NTAPI
 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 b0d578d5ae9..ed6d6005221 100644
--- a/reactos/drivers/filesystems/npfs/npfs.c
+++ b/reactos/drivers/filesystems/npfs/npfs.c
@@ -17,73 +17,73 @@
 
 NTSTATUS NTAPI
 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 3720c95aae3..373980ce6d5 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 ClientReadMode;
-	ULONG ServerReadMode;
-	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 ClientReadMode;
+    ULONG ServerReadMode;
+    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);
 
@@ -133,6 +133,6 @@ NTSTATUS NTAPI NpfsQueryVolumeInformation (PDEVICE_OBJECT DeviceObject, PIRP Irp
 
 NTSTATUS NTAPI
 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 092b0ee0dda..9a562a47418 100644
--- a/reactos/drivers/filesystems/npfs/rw.c
+++ b/reactos/drivers/filesystems/npfs/rw.c
@@ -18,938 +18,938 @@
 
 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");
 }
 
 static DRIVER_CANCEL NpfsReadWriteCancelRoutine;
 static VOID NTAPI
 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 %p, Irp %p)\n", DeviceObject, Irp);
+    DPRINT("NpfsReadWriteCancelRoutine(DeviceObject %p, Irp %p)\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:
-		ASSERT(FALSE);
-	}
-	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:
+        ASSERT(FALSE);
+    }
+    ExReleaseFastMutex(&Ccb->DataListLock);
+    KeUnlockMutex(&DeviceExt->PipeListLock);
+    if (Complete)
+    {
+        Irp->IoStatus.Status = STATUS_CANCELLED;
+        Irp->IoStatus.Information = 0;
+        IoCompleteRequest(Irp, IO_NO_INCREMENT);
+    }
 }
 
 static VOID NTAPI
 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:
-					ASSERT(FALSE);
-				}
-			}
-		}
-		if (Terminate)
-		{
-			break;
-		}
-		Status = KeWaitForMultipleObjects(CurrentCount,
-			ThreadContext->WaitObjectArray,
-			WaitAny,
-			Executive,
-			KernelMode,
-			FALSE,
-			NULL,
-			ThreadContext->WaitBlockArray);
-		if (!NT_SUCCESS(Status))
-		{
-			ASSERT(FALSE);
-		}
-		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:
+                    ASSERT(FALSE);
+                }
+            }
+        }
+        if (Terminate)
+        {
+            break;
+        }
+        Status = KeWaitForMultipleObjects(CurrentCount,
+            ThreadContext->WaitObjectArray,
+            WaitAny,
+            Executive,
+            KernelMode,
+            FALSE,
+            NULL,
+            ThreadContext->WaitBlockArray);
+        if (!NT_SUCCESS(Status))
+        {
+            ASSERT(FALSE);
+        }
+        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:
-					ASSERT(FALSE);
-				}
-				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:
+                    ASSERT(FALSE);
+                }
+                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 NTAPI
 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 = 0;
-	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 = 0;
+    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;
-	}
+    if (Irp->MdlAddress == NULL)
+    {
+        DPRINT("Irp->MdlAddress == NULL\n");
+        Status = STATUS_UNSUCCESSFUL;
+        Irp->IoStatus.Information = 0;
+        goto done;
+    }
 
-	FileObject = IoGetCurrentIrpStackLocation(Irp)->FileObject;
-	DPRINT("FileObject %p\n", FileObject);
-	DPRINT("Pipe name %wZ\n", &FileObject->FileName);
-	Ccb = FileObject->FsContext2;
-	Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext;
+    FileObject = IoGetCurrentIrpStackLocation(Irp)->FileObject;
+    DPRINT("FileObject %p\n", FileObject);
+    DPRINT("Pipe name %wZ\n", &FileObject->FileName);
+    Ccb = FileObject->FsContext2;
+    Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext;
 
-	if ((Ccb->OtherSide) && (Ccb->OtherSide->PipeState == FILE_PIPE_DISCONNECTED_STATE) && (Ccb->PipeState == FILE_PIPE_DISCONNECTED_STATE))
-	{
-		DPRINT("Both Client and Server are disconnected!\n");
-		Status = STATUS_PIPE_DISCONNECTED;
-		Irp->IoStatus.Information = 0;
-		goto done;
+    if ((Ccb->OtherSide) && (Ccb->OtherSide->PipeState == FILE_PIPE_DISCONNECTED_STATE) && (Ccb->PipeState == FILE_PIPE_DISCONNECTED_STATE))
+    {
+        DPRINT("Both Client and Server are disconnected!\n");
+        Status = STATUS_PIPE_DISCONNECTED;
+        Irp->IoStatus.Information = 0;
+        goto done;
 
-	}
+    }
 
-	if ((Ccb->OtherSide == NULL) && (Ccb->ReadDataAvailable == 0))
-	{
-		/* Its ok if the other side has been Disconnect, but if we have data still in the buffer
+    if ((Ccb->OtherSide == NULL) && (Ccb->ReadDataAvailable == 0))
+    {
+        /* Its ok if the other side has been Disconnect, but if we have data still in the buffer
                    , need to still be able to read it. Currently this is a HAXXXX */
-		DPRINT("Pipe no longer connected and no data exist in buffer. Ok to close pipe\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;
-	}
+        DPRINT("Pipe no longer connected and no data exist in buffer. Ok to close pipe\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)
-	{
-		DPRINT("Pipe is NOT readable!\n");
-		Status = STATUS_UNSUCCESSFUL;
-		Irp->IoStatus.Information = 0;
-		goto done;
-	}
+    if (Ccb->Data == NULL)
+    {
+        DPRINT("Pipe is NOT readable!\n");
+        Status = STATUS_UNSUCCESSFUL;
+        Irp->IoStatus.Information = 0;
+        goto done;
+    }
 
-	ExAcquireFastMutex(&Ccb->DataListLock);
+    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,
-				Irp->RequestorMode,
-				FALSE,
-				NULL);
-			if ((Status == STATUS_USER_APC) || (Status == STATUS_KERNEL_APC))
-			{
-				Status = STATUS_CANCELLED;
-				goto done;
-			}
-			if (!NT_SUCCESS(Status))
-			{
-				ASSERT(FALSE);
-			}
-			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;
-			}
-		}
-	}
+    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,
+                Irp->RequestorMode,
+                FALSE,
+                NULL);
+            if ((Status == STATUS_USER_APC) || (Status == STATUS_KERNEL_APC))
+            {
+                Status = STATUS_CANCELLED;
+                goto done;
+            }
+            if (!NT_SUCCESS(Status))
+            {
+                ASSERT(FALSE);
+            }
+            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;
+            }
+        }
+    }
 
-	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;
+    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;
 
-		while (1)
-		{
-			if (Ccb->ReadDataAvailable == 0)
-			{
-				ULONG ConnectionSideReadMode;
+        while (1)
+        {
+            if (Ccb->ReadDataAvailable == 0)
+            {
+                ULONG ConnectionSideReadMode;
 
-				if (Ccb->PipeEnd == FILE_PIPE_CLIENT_END) ConnectionSideReadMode=Ccb->Fcb->ClientReadMode;
-				else ConnectionSideReadMode = Ccb->Fcb->ServerReadMode;
+                if (Ccb->PipeEnd == FILE_PIPE_CLIENT_END) ConnectionSideReadMode=Ccb->Fcb->ClientReadMode;
+                else ConnectionSideReadMode = Ccb->Fcb->ServerReadMode;
 
-				if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE)
-				{
-					ASSERT(Ccb->OtherSide != NULL);
-					KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE);
-				}
-				if (Information > 0 &&
-					(ConnectionSideReadMode != FILE_PIPE_BYTE_STREAM_MODE ||
-					Ccb->PipeState != FILE_PIPE_CONNECTED_STATE))
-				{
-					break;
-				}
-				if ((Ccb->PipeState != FILE_PIPE_CONNECTED_STATE) && (Ccb->ReadDataAvailable == 0))
-				{
-					DPRINT("PipeState: %x\n", Ccb->PipeState);
-					Status = STATUS_PIPE_BROKEN;
-					break;
-				}
-				ExReleaseFastMutex(&Ccb->DataListLock);
+                if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE)
+                {
+                    ASSERT(Ccb->OtherSide != NULL);
+                    KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE);
+                }
+                if (Information > 0 &&
+                    (ConnectionSideReadMode != FILE_PIPE_BYTE_STREAM_MODE ||
+                    Ccb->PipeState != FILE_PIPE_CONNECTED_STATE))
+                {
+                    break;
+                }
+                if ((Ccb->PipeState != FILE_PIPE_CONNECTED_STATE) && (Ccb->ReadDataAvailable == 0))
+                {
+                    DPRINT("PipeState: %x\n", Ccb->PipeState);
+                    Status = STATUS_PIPE_BROKEN;
+                    break;
+                }
+                ExReleaseFastMutex(&Ccb->DataListLock);
 
-				if (IoIsOperationSynchronous(Irp))
-				{
-					/* Wait for ReadEvent to become signaled */
+                if (IoIsOperationSynchronous(Irp))
+                {
+                    /* Wait for ReadEvent to become signaled */
 
-					DPRINT("Waiting for readable data (%wZ)\n", &Ccb->Fcb->PipeName);
-					Status = KeWaitForSingleObject(&Ccb->ReadEvent,
-						UserRequest,
-						Irp->RequestorMode,
-						FALSE,
-						NULL);
-					DPRINT("Finished waiting (%wZ)! Status: %x\n", &Ccb->Fcb->PipeName, Status);
+                    DPRINT("Waiting for readable data (%wZ)\n", &Ccb->Fcb->PipeName);
+                    Status = KeWaitForSingleObject(&Ccb->ReadEvent,
+                        UserRequest,
+                        Irp->RequestorMode,
+                        FALSE,
+                        NULL);
+                    DPRINT("Finished waiting (%wZ)! Status: %x\n", &Ccb->Fcb->PipeName, Status);
 
-					if ((Status == STATUS_USER_APC) || (Status == STATUS_KERNEL_APC))
-					{
-						Status = STATUS_CANCELLED;
-						break;
-					}
-					if (!NT_SUCCESS(Status))
-					{
-						ASSERT(FALSE);
-					}
-					ExAcquireFastMutex(&Ccb->DataListLock);
-				}
-				else
-				{
-					Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext;
+                    if ((Status == STATUS_USER_APC) || (Status == STATUS_KERNEL_APC))
+                    {
+                        Status = STATUS_CANCELLED;
+                        break;
+                    }
+                    if (!NT_SUCCESS(Status))
+                    {
+                        ASSERT(FALSE);
+                    }
+                    ExAcquireFastMutex(&Ccb->DataListLock);
+                }
+                else
+                {
+                    Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext;
 
-					Context->WaitEvent = &Ccb->ReadEvent;
-					Status = NpfsAddWaitingReadWriteRequest(DeviceObject, Irp);
+                    Context->WaitEvent = &Ccb->ReadEvent;
+                    Status = NpfsAddWaitingReadWriteRequest(DeviceObject, Irp);
 
-					if (NT_SUCCESS(Status))
-					{
-						Status = STATUS_PENDING;
-						goto done;
-					}
-					ExAcquireFastMutex(&Ccb->DataListLock);
-					break;
-				}
-			}
-			ASSERT(IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL);
+                    if (NT_SUCCESS(Status))
+                    {
+                        Status = STATUS_PENDING;
+                        goto done;
+                    }
+                    ExAcquireFastMutex(&Ccb->DataListLock);
+                    break;
+                }
+            }
+            ASSERT(IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL);
 
-			/* If the pipe type and read mode are both byte stream */
-			if (Ccb->Fcb->PipeType == FILE_PIPE_BYTE_STREAM_TYPE)
-			{
-				DPRINT("Byte stream mode: Ccb->Data %x\n", Ccb->Data);
-				/* 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);
-					}
+            /* If the pipe type and read mode are both byte stream */
+            if (Ccb->Fcb->PipeType == FILE_PIPE_BYTE_STREAM_TYPE)
+            {
+                DPRINT("Byte stream mode: Ccb->Data %x\n", Ccb->Data);
+                /* 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);
+                    }
 
-					Buffer = (PVOID)((ULONG_PTR)Buffer + CopyLength);
-					Length -= CopyLength;
-					Information += CopyLength;
+                    Buffer = (PVOID)((ULONG_PTR)Buffer + CopyLength);
+                    Length -= CopyLength;
+                    Information += CopyLength;
 
-					Ccb->ReadDataAvailable -= CopyLength;
-					Ccb->WriteQuotaAvailable += CopyLength;
-				}
+                    Ccb->ReadDataAvailable -= CopyLength;
+                    Ccb->WriteQuotaAvailable += CopyLength;
+                }
 
-				if ((Length == 0) || (Ccb->ReadDataAvailable == 0))
-				{
-					if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE)
-					{
-						KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE);
-					}
-					KeResetEvent(&Ccb->ReadEvent);
-					break;
-				}
-			}
-			else if (Ccb->Fcb->PipeType == FILE_PIPE_MESSAGE_TYPE)
-			{
-				DPRINT("Message mode: Ccb>Data %x\n", Ccb->Data);
+                if ((Length == 0) || (Ccb->ReadDataAvailable == 0))
+                {
+                    if (Ccb->PipeState == FILE_PIPE_CONNECTED_STATE)
+                    {
+                        KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE);
+                    }
+                    KeResetEvent(&Ccb->ReadEvent);
+                    break;
+                }
+            }
+            else if (Ccb->Fcb->PipeType == FILE_PIPE_MESSAGE_TYPE)
+            {
+                DPRINT("Message mode: Ccb>Data %x\n", Ccb->Data);
 
-				/* Check if buffer is full and the read pointer is not at the start of the buffer */
-				if ((Ccb->WriteQuotaAvailable == 0) && (Ccb->ReadPtr > Ccb->Data))
-				{
-					Ccb->WriteQuotaAvailable += (ULONG_PTR)Ccb->ReadPtr - (ULONG_PTR)Ccb->Data;
-					memcpy(Ccb->Data, Ccb->ReadPtr, (ULONG_PTR)Ccb->WritePtr - (ULONG_PTR)Ccb->ReadPtr);
-					Ccb->WritePtr = (PVOID)((ULONG_PTR)Ccb->WritePtr - ((ULONG_PTR)Ccb->ReadPtr - (ULONG_PTR)Ccb->Data));
-					Ccb->ReadPtr = Ccb->Data;
-				}
+                /* Check if buffer is full and the read pointer is not at the start of the buffer */
+                if ((Ccb->WriteQuotaAvailable == 0) && (Ccb->ReadPtr > Ccb->Data))
+                {
+                    Ccb->WriteQuotaAvailable += (ULONG_PTR)Ccb->ReadPtr - (ULONG_PTR)Ccb->Data;
+                    memcpy(Ccb->Data, Ccb->ReadPtr, (ULONG_PTR)Ccb->WritePtr - (ULONG_PTR)Ccb->ReadPtr);
+                    Ccb->WritePtr = (PVOID)((ULONG_PTR)Ccb->WritePtr - ((ULONG_PTR)Ccb->ReadPtr - (ULONG_PTR)Ccb->Data));
+                    Ccb->ReadPtr = Ccb->Data;
+                }
 
-				/* For Message mode, the Message length is stored in the buffer preceeding the Message. */
-				if (Ccb->ReadDataAvailable)
-				{
-					ULONG NextMessageLength = 0;
+                /* For Message mode, the Message length is stored in the buffer preceeding the Message. */
+                if (Ccb->ReadDataAvailable)
+                {
+                    ULONG NextMessageLength = 0;
 
-					/*First get the size of the message */
-					memcpy(&NextMessageLength, Ccb->ReadPtr, sizeof(NextMessageLength));
+                    /*First get the size of the message */
+                    memcpy(&NextMessageLength, Ccb->ReadPtr, sizeof(NextMessageLength));
 
-					if ((NextMessageLength == 0) || (NextMessageLength > Ccb->ReadDataAvailable))
-					{
-						DPRINT1("Possible memory corruption.\n");
-						HexDump(Ccb->Data, (ULONG_PTR)Ccb->WritePtr - (ULONG_PTR)Ccb->Data);
-						ASSERT(FALSE);
-					}
+                    if ((NextMessageLength == 0) || (NextMessageLength > Ccb->ReadDataAvailable))
+                    {
+                        DPRINT1("Possible memory corruption.\n");
+                        HexDump(Ccb->Data, (ULONG_PTR)Ccb->WritePtr - (ULONG_PTR)Ccb->Data);
+                        ASSERT(FALSE);
+                    }
 
-					/* Use the smaller value */
-					CopyLength = min(NextMessageLength, Length);
-					ASSERT(CopyLength > 0);
-					ASSERT(CopyLength <= Ccb->ReadDataAvailable);
-					/* retrieve the message from the buffer */
-					memcpy(Buffer, (PVOID)((ULONG_PTR)Ccb->ReadPtr + sizeof(NextMessageLength)), CopyLength);
+                    /* Use the smaller value */
+                    CopyLength = min(NextMessageLength, Length);
+                    ASSERT(CopyLength > 0);
+                    ASSERT(CopyLength <= Ccb->ReadDataAvailable);
+                    /* retrieve the message from the buffer */
+                    memcpy(Buffer, (PVOID)((ULONG_PTR)Ccb->ReadPtr + sizeof(NextMessageLength)), CopyLength);
 
-					if (Ccb->ReadDataAvailable > CopyLength)
-					{
-						if (CopyLength < NextMessageLength)
-						/* Client only requested part of the message */
-						{
-							/* Calculate the remaining message new size */
-							ULONG NewMessageSize = NextMessageLength-CopyLength;
+                    if (Ccb->ReadDataAvailable > CopyLength)
+                    {
+                        if (CopyLength < NextMessageLength)
+                        /* Client only requested part of the message */
+                        {
+                            /* Calculate the remaining message new size */
+                            ULONG NewMessageSize = NextMessageLength-CopyLength;
 
-							/* Update ReadPtr to point to new Message size location */
-							Ccb->ReadPtr = (PVOID)((ULONG_PTR)Ccb->ReadPtr + CopyLength);
+                            /* Update ReadPtr to point to new Message size location */
+                            Ccb->ReadPtr = (PVOID)((ULONG_PTR)Ccb->ReadPtr + CopyLength);
 
-							/* Write a new Message size to buffer for the part of the message still there */
-							memcpy(Ccb->ReadPtr, &NewMessageSize, sizeof(NewMessageSize));
-						}
-						else
-						/* Client wanted the entire message */
-						{
-							/* Update ReadPtr to point to next message size */
-							Ccb->ReadPtr = (PVOID)((ULONG_PTR)Ccb->ReadPtr + CopyLength + sizeof(CopyLength));
-						}
-					}
-					else
-					{
-						/* This was the last Message, so just zero start of buffer for safety sake */
-						memset(Ccb->Data, 0, NextMessageLength + sizeof(NextMessageLength));
+                            /* Write a new Message size to buffer for the part of the message still there */
+                            memcpy(Ccb->ReadPtr, &NewMessageSize, sizeof(NewMessageSize));
+                        }
+                        else
+                        /* Client wanted the entire message */
+                        {
+                            /* Update ReadPtr to point to next message size */
+                            Ccb->ReadPtr = (PVOID)((ULONG_PTR)Ccb->ReadPtr + CopyLength + sizeof(CopyLength));
+                        }
+                    }
+                    else
+                    {
+                        /* This was the last Message, so just zero start of buffer for safety sake */
+                        memset(Ccb->Data, 0, NextMessageLength + sizeof(NextMessageLength));
 
-						/* Reset to MaxDataLength as partial message retrievals dont
-						   give the length back to Quota */
-						Ccb->WriteQuotaAvailable = Ccb->MaxDataLength;
+                        /* Reset to MaxDataLength as partial message retrievals dont
+                           give the length back to Quota */
+                        Ccb->WriteQuotaAvailable = Ccb->MaxDataLength;
 
-						/* reset read and write pointer to beginning of buffer */
-						Ccb->WritePtr = Ccb->Data;
-						Ccb->ReadPtr = Ccb->Data;
-					}
+                        /* reset read and write pointer to beginning of buffer */
+                        Ccb->WritePtr = Ccb->Data;
+                        Ccb->ReadPtr = Ccb->Data;
+                    }
 #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;
 
-					Ccb->ReadDataAvailable -= CopyLength;
+                    Ccb->ReadDataAvailable -= CopyLength;
 
-					if ((ULONG)Ccb->WriteQuotaAvailable > (ULONG)Ccb->MaxDataLength) ASSERT(FALSE);
-				}
+                    if ((ULONG)Ccb->WriteQuotaAvailable > (ULONG)Ccb->MaxDataLength) ASSERT(FALSE);
+                }
 
-				if (Information > 0)
-				{
-					ULONG ConnectionSideReadMode;
+                if (Information > 0)
+                {
+                    ULONG ConnectionSideReadMode;
 
-					if (Ccb->PipeEnd == FILE_PIPE_CLIENT_END) ConnectionSideReadMode=Ccb->Fcb->ClientReadMode;
-					else ConnectionSideReadMode = Ccb->Fcb->ServerReadMode;
+                    if (Ccb->PipeEnd == FILE_PIPE_CLIENT_END) ConnectionSideReadMode=Ccb->Fcb->ClientReadMode;
+                    else ConnectionSideReadMode = Ccb->Fcb->ServerReadMode;
 
-					if ((ConnectionSideReadMode == FILE_PIPE_BYTE_STREAM_MODE) && (Ccb->ReadDataAvailable) && (Length > CopyLength))
-					{
-						Buffer = (PVOID)((ULONG_PTR)Buffer + CopyLength);
-						Length -= CopyLength;
-					}
-					else 
-					{
-						KeResetEvent(&Ccb->ReadEvent);
+                    if ((ConnectionSideReadMode == FILE_PIPE_BYTE_STREAM_MODE) && (Ccb->ReadDataAvailable) && (Length > CopyLength))
+                    {
+                        Buffer = (PVOID)((ULONG_PTR)Buffer + CopyLength);
+                        Length -= CopyLength;
+                    }
+                    else 
+                    {
+                        KeResetEvent(&Ccb->ReadEvent);
 
-						if ((Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) && (Ccb->WriteQuotaAvailable > 0))
-						{
-							KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE);
-						}
-						break;
-					}
-				}
-			}
-			else
-			{
-				DPRINT1("Unhandled Pipe Mode!\n");
-				ASSERT(FALSE);
-			}
-		}
-		Irp->IoStatus.Information = Information;
-		Irp->IoStatus.Status = Status;
+                        if ((Ccb->PipeState == FILE_PIPE_CONNECTED_STATE) && (Ccb->WriteQuotaAvailable > 0))
+                        {
+                            KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE);
+                        }
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                DPRINT1("Unhandled Pipe Mode!\n");
+                ASSERT(FALSE);
+            }
+        }
+        Irp->IoStatus.Information = Information;
+        Irp->IoStatus.Status = Status;
 
-		ASSERT(IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL);
+        ASSERT(IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL);
 
-		if (Status == STATUS_CANCELLED)
-			goto done;
+        if (Status == STATUS_CANCELLED)
+            goto done;
 
-		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);
+        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
-		{
-			KIRQL oldIrql;
+            DPRINT("NpfsRead done (Status %lx)\n", Status);
+            return Status;
+        }
+        else
+        {
+            KIRQL oldIrql;
 
-			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;
-			}
-			
-			IoAcquireCancelSpinLock(&oldIrql);
-			Context = CONTAINING_RECORD(Ccb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry);
+            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;
+            }
 
-			Irp = CONTAINING_RECORD(Context, IRP, Tail.Overlay.DriverContext);
-			/* Verify the Irp wasnt cancelled */
-			if (Irp->Cancel)
-			{
-				IoReleaseCancelSpinLock(oldIrql);
-				RemoveEntryList(&Context->ListEntry);
-				ExReleaseFastMutex(&Ccb->DataListLock);
-				Status = STATUS_CANCELLED;
-				goto done;
-			}
-			/* The Irp will now be handled, so remove the CancelRoutine */
-			(void)IoSetCancelRoutine(Irp, NULL);
-			IoReleaseCancelSpinLock(oldIrql);
-		}
-	}
+            IoAcquireCancelSpinLock(&oldIrql);
+            Context = CONTAINING_RECORD(Ccb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry);
+
+            Irp = CONTAINING_RECORD(Context, IRP, Tail.Overlay.DriverContext);
+            /* Verify the Irp wasnt cancelled */
+            if (Irp->Cancel)
+            {
+                IoReleaseCancelSpinLock(oldIrql);
+                RemoveEntryList(&Context->ListEntry);
+                ExReleaseFastMutex(&Ccb->DataListLock);
+                Status = STATUS_CANCELLED;
+                goto done;
+            }
+            /* The Irp will now be handled, so remove the CancelRoutine */
+            (void)IoSetCancelRoutine(Irp, NULL);
+            IoReleaseCancelSpinLock(oldIrql);
+        }
+    }
 
 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 NTAPI
 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) || (Ccb->PipeState != FILE_PIPE_CONNECTED_STATE))
-	{
-		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) || (Ccb->PipeState != FILE_PIPE_CONNECTED_STATE))
+    {
+        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))
-		{
-			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);
+    while(1)
+    {
+        if ((ReaderCcb->WriteQuotaAvailable == 0))
+        {
+            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("Write Waiting for buffer space (%S)\n", Fcb->PipeName.Buffer);
-			Status = KeWaitForSingleObject(&Ccb->WriteEvent,
-				UserRequest,
-				Irp->RequestorMode,
-				FALSE,
-				NULL);
-			DPRINT("Write Finished waiting (%S)! Status: %x\n", Fcb->PipeName.Buffer, Status);
-			
-			if ((Status == STATUS_USER_APC) || (Status == STATUS_KERNEL_APC))
-			{
-				Status = STATUS_CANCELLED;
-				break;
-			}
-			if (!NT_SUCCESS(Status))
-			{
-				ASSERT(FALSE);
-			}
-			/*
-			* 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;
-				goto done;
-			}
-			ExAcquireFastMutex(&ReaderCcb->DataListLock);
-		}
+            DPRINT("Write Waiting for buffer space (%S)\n", Fcb->PipeName.Buffer);
+            Status = KeWaitForSingleObject(&Ccb->WriteEvent,
+                UserRequest,
+                Irp->RequestorMode,
+                FALSE,
+                NULL);
+            DPRINT("Write Finished waiting (%S)! Status: %x\n", Fcb->PipeName.Buffer, Status);
 
-		if (Ccb->Fcb->PipeType == FILE_PIPE_BYTE_STREAM_TYPE)
-		{
-			DPRINT("Byte stream mode: Ccb->Data %x, Ccb->WritePtr %x\n", ReaderCcb->Data, ReaderCcb->WritePtr);
+            if ((Status == STATUS_USER_APC) || (Status == STATUS_KERNEL_APC))
+            {
+                Status = STATUS_CANCELLED;
+                break;
+            }
+            if (!NT_SUCCESS(Status))
+            {
+                ASSERT(FALSE);
+            }
+            /*
+            * 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;
+                goto done;
+            }
+            ExAcquireFastMutex(&ReaderCcb->DataListLock);
+        }
 
-			while (Length > 0 && ReaderCcb->WriteQuotaAvailable > 0)
-			{
-				CopyLength = min(Length, ReaderCcb->WriteQuotaAvailable);
+        if (Ccb->Fcb->PipeType == FILE_PIPE_BYTE_STREAM_TYPE)
+        {
+            DPRINT("Byte stream mode: Ccb->Data %x, Ccb->WritePtr %x\n", ReaderCcb->Data, ReaderCcb->WritePtr);
 
-				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
-				{
+            while (Length > 0 && ReaderCcb->WriteQuotaAvailable > 0)
+            {
+                CopyLength = min(Length, ReaderCcb->WriteQuotaAvailable);
 
-					TempLength = (ULONG)((ULONG_PTR)ReaderCcb->Data + ReaderCcb->MaxDataLength -
-							(ULONG_PTR)ReaderCcb->WritePtr);
+                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
+                {
 
-					memcpy(ReaderCcb->WritePtr, Buffer, TempLength);
-					memcpy(ReaderCcb->Data, Buffer + TempLength, CopyLength - TempLength);
-					ReaderCcb->WritePtr = (PVOID)((ULONG_PTR)ReaderCcb->Data + CopyLength - TempLength);
-				}
+                    TempLength = (ULONG)((ULONG_PTR)ReaderCcb->Data + ReaderCcb->MaxDataLength -
+                            (ULONG_PTR)ReaderCcb->WritePtr);
 
-				Buffer += CopyLength;
-				Length -= CopyLength;
-				Information += CopyLength;
+                    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;
-			}
-		}
-		else if (Ccb->Fcb->PipeType == FILE_PIPE_MESSAGE_TYPE)
-		{
-			/* For Message Type Pipe, the Pipes memory will be used to store the size of each message */
-			DPRINT("Message mode: Ccb->Data %x, Ccb->WritePtr %x\n",ReaderCcb->Data, ReaderCcb->WritePtr);
-			if (Length > 0)
-			{
-				/* Verify the WritePtr is still inside the buffer */
-				if (((ULONG_PTR)ReaderCcb->WritePtr > ((ULONG_PTR)ReaderCcb->Data + (ULONG_PTR)ReaderCcb->MaxDataLength)) ||
-				((ULONG_PTR)ReaderCcb->WritePtr < (ULONG_PTR)ReaderCcb->Data))
-				{
-					DPRINT1("NPFS is writing out of its buffer. Report to developer!\n");
-					DPRINT1("ReaderCcb->WritePtr %x, ReaderCcb->Data %x, ReaderCcb->MaxDataLength %lu\n",
-						ReaderCcb->WritePtr, ReaderCcb->Data, ReaderCcb->MaxDataLength);
-					ASSERT(FALSE);
-				}
+                ReaderCcb->ReadDataAvailable += CopyLength;
+                ReaderCcb->WriteQuotaAvailable -= CopyLength;
+            }
 
-				CopyLength = min(Length, ReaderCcb->WriteQuotaAvailable - sizeof(ULONG));
-				if (CopyLength > ReaderCcb->WriteQuotaAvailable)
-				{
-					DPRINT1("Writing %lu byte to pipe would overflow as only %lu bytes are available\n",
-						CopyLength, ReaderCcb->WriteQuotaAvailable);
-					ASSERT(FALSE);
-				}
+            if (Length == 0)
+            {
+                KeSetEvent(&ReaderCcb->ReadEvent, IO_NO_INCREMENT, FALSE);
+                KeResetEvent(&Ccb->WriteEvent);
+                break;
+            }
+        }
+        else if (Ccb->Fcb->PipeType == FILE_PIPE_MESSAGE_TYPE)
+        {
+            /* For Message Type Pipe, the Pipes memory will be used to store the size of each message */
+            DPRINT("Message mode: Ccb->Data %x, Ccb->WritePtr %x\n",ReaderCcb->Data, ReaderCcb->WritePtr);
+            if (Length > 0)
+            {
+                /* Verify the WritePtr is still inside the buffer */
+                if (((ULONG_PTR)ReaderCcb->WritePtr > ((ULONG_PTR)ReaderCcb->Data + (ULONG_PTR)ReaderCcb->MaxDataLength)) ||
+                ((ULONG_PTR)ReaderCcb->WritePtr < (ULONG_PTR)ReaderCcb->Data))
+                {
+                    DPRINT1("NPFS is writing out of its buffer. Report to developer!\n");
+                    DPRINT1("ReaderCcb->WritePtr %x, ReaderCcb->Data %x, ReaderCcb->MaxDataLength %lu\n",
+                        ReaderCcb->WritePtr, ReaderCcb->Data, ReaderCcb->MaxDataLength);
+                    ASSERT(FALSE);
+                }
 
-				/* First Copy the Length of the message into the pipes buffer */
-				memcpy(ReaderCcb->WritePtr, &CopyLength, sizeof(CopyLength));
+                CopyLength = min(Length, ReaderCcb->WriteQuotaAvailable - sizeof(ULONG));
+                if (CopyLength > ReaderCcb->WriteQuotaAvailable)
+                {
+                    DPRINT1("Writing %lu byte to pipe would overflow as only %lu bytes are available\n",
+                        CopyLength, ReaderCcb->WriteQuotaAvailable);
+                    ASSERT(FALSE);
+                }
 
-				/* Now the user buffer itself */
-				memcpy((PVOID)((ULONG_PTR)ReaderCcb->WritePtr + sizeof(CopyLength)), Buffer, CopyLength);
+                /* First Copy the Length of the message into the pipes buffer */
+                memcpy(ReaderCcb->WritePtr, &CopyLength, sizeof(CopyLength));
 
-				/* Update the write pointer */
-				ReaderCcb->WritePtr = (PVOID)((ULONG_PTR)ReaderCcb->WritePtr + sizeof(CopyLength) + CopyLength);
+                /* Now the user buffer itself */
+                memcpy((PVOID)((ULONG_PTR)ReaderCcb->WritePtr + sizeof(CopyLength)), Buffer, CopyLength);
 
-				Information += CopyLength;
+                /* Update the write pointer */
+                ReaderCcb->WritePtr = (PVOID)((ULONG_PTR)ReaderCcb->WritePtr + sizeof(CopyLength) + CopyLength);
 
-				ReaderCcb->ReadDataAvailable += CopyLength;
+                Information += CopyLength;
 
-				ReaderCcb->WriteQuotaAvailable -= (CopyLength + sizeof(ULONG));
+                ReaderCcb->ReadDataAvailable += CopyLength;
 
-				if ((ULONG_PTR)ReaderCcb->WriteQuotaAvailable > (ULONG)ReaderCcb->MaxDataLength)
-				{
-					DPRINT1("QuotaAvailable is greater than buffer size!\n");
-					ASSERT(FALSE);
-				}
-			}
+                ReaderCcb->WriteQuotaAvailable -= (CopyLength + sizeof(ULONG));
 
-			if (Information > 0)
-			{
-				KeSetEvent(&ReaderCcb->ReadEvent, IO_NO_INCREMENT, FALSE);
-				KeResetEvent(&Ccb->WriteEvent);
-				break;
-			}
-		}
-		else
-		{
-			DPRINT1("Unhandled Pipe Type Mode and Read Write Mode!\n");
-			ASSERT(FALSE);
-		}
-	}
+                if ((ULONG_PTR)ReaderCcb->WriteQuotaAvailable > (ULONG)ReaderCcb->MaxDataLength)
+                {
+                    DPRINT1("QuotaAvailable is greater than buffer size!\n");
+                    ASSERT(FALSE);
+                }
+            }
 
-	ExReleaseFastMutex(&ReaderCcb->DataListLock);
+            if (Information > 0)
+            {
+                KeSetEvent(&ReaderCcb->ReadEvent, IO_NO_INCREMENT, FALSE);
+                KeResetEvent(&Ccb->WriteEvent);
+                break;
+            }
+        }
+        else
+        {
+            DPRINT1("Unhandled Pipe Type Mode and Read Write Mode!\n");
+            ASSERT(FALSE);
+        }
+    }
+
+    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 4f3d80eb92f..4241c88ec3d 100644
--- a/reactos/drivers/filesystems/npfs/volume.c
+++ b/reactos/drivers/filesystems/npfs/volume.c
@@ -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 NTAPI
 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 %p, Irp %p)\n",
-		DeviceObject,
-		Irp);
+    DPRINT("NpfsQueryVolumeInformation(DeviceObject %p, Irp %p)\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 %p\n", SystemBuffer);
+    DPRINT("FsInformationClass %d\n", FsInformationClass);
+    DPRINT("SystemBuffer %p\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 */