2003-07-17 13:31:39 +00:00
|
|
|
/*
|
|
|
|
* ReactOS kernel
|
2014-11-02 21:50:40 +00:00
|
|
|
* Copyright (C) 2002, 2014 ReactOS Team
|
2003-07-17 13:31:39 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
2008-03-08 21:45:51 +00:00
|
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
|
2003-07-17 13:31:39 +00:00
|
|
|
*
|
|
|
|
* COPYRIGHT: See COPYING in the top level directory
|
|
|
|
* PROJECT: ReactOS kernel
|
2008-02-10 11:20:29 +00:00
|
|
|
* FILE: drivers/filesystem/ntfs/rw.c
|
2013-06-16 12:15:06 +00:00
|
|
|
* PURPOSE: NTFS filesystem driver
|
2014-11-02 21:50:40 +00:00
|
|
|
* PROGRAMMERS: Art Yerkes
|
|
|
|
* Pierre Schweitzer (pierre@reactos.org)
|
2003-07-17 13:31:39 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* INCLUDES *****************************************************************/
|
|
|
|
|
2005-12-01 21:37:19 +00:00
|
|
|
#include <ntddk.h>
|
2013-06-16 12:15:06 +00:00
|
|
|
#include "ntfs.h"
|
2003-07-17 13:31:39 +00:00
|
|
|
|
2004-06-05 08:28:37 +00:00
|
|
|
#define NDEBUG
|
2003-07-17 13:31:39 +00:00
|
|
|
#include <debug.h>
|
|
|
|
|
|
|
|
/* FUNCTIONS ****************************************************************/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* FUNCTION: Reads data from a file
|
|
|
|
*/
|
2013-06-16 12:15:06 +00:00
|
|
|
static
|
|
|
|
NTSTATUS
|
|
|
|
NtfsReadFile(PDEVICE_EXTENSION DeviceExt,
|
|
|
|
PFILE_OBJECT FileObject,
|
|
|
|
PUCHAR Buffer,
|
|
|
|
ULONG Length,
|
|
|
|
ULONG ReadOffset,
|
|
|
|
ULONG IrpFlags,
|
|
|
|
PULONG LengthRead)
|
2003-07-17 13:31:39 +00:00
|
|
|
{
|
2014-11-02 19:55:22 +00:00
|
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
|
|
PNTFS_FCB Fcb;
|
|
|
|
PFILE_RECORD_HEADER FileRecord;
|
|
|
|
PNTFS_ATTR_CONTEXT DataContext;
|
|
|
|
ULONG RealLength;
|
|
|
|
ULONG RealReadOffset;
|
|
|
|
ULONG RealLengthRead;
|
|
|
|
ULONG ToRead;
|
|
|
|
BOOLEAN AllocatedBuffer = FALSE;
|
|
|
|
PCHAR ReadBuffer = (PCHAR)Buffer;
|
2015-06-28 13:14:07 +00:00
|
|
|
ULONGLONG StreamSize;
|
2014-11-02 19:55:22 +00:00
|
|
|
|
|
|
|
DPRINT1("NtfsReadFile(%p, %p, %p, %u, %u, %x, %p)\n", DeviceExt, FileObject, Buffer, Length, ReadOffset, IrpFlags, LengthRead);
|
2003-07-17 13:31:39 +00:00
|
|
|
|
2014-11-02 19:55:22 +00:00
|
|
|
*LengthRead = 0;
|
2003-07-17 13:31:39 +00:00
|
|
|
|
2014-11-02 19:55:22 +00:00
|
|
|
if (Length == 0)
|
|
|
|
{
|
|
|
|
DPRINT1("Null read!\n");
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
}
|
2003-07-17 13:31:39 +00:00
|
|
|
|
2014-11-02 19:55:22 +00:00
|
|
|
Fcb = (PNTFS_FCB)FileObject->FsContext;
|
2003-07-17 13:31:39 +00:00
|
|
|
|
2016-02-14 22:44:54 +00:00
|
|
|
if (NtfsFCBIsCompressed(Fcb))
|
|
|
|
{
|
|
|
|
DPRINT1("Compressed file!\n");
|
|
|
|
UNIMPLEMENTED;
|
|
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
2014-11-02 19:55:22 +00:00
|
|
|
FileRecord = ExAllocatePoolWithTag(NonPagedPool, DeviceExt->NtfsInfo.BytesPerFileRecord, TAG_NTFS);
|
|
|
|
if (FileRecord == NULL)
|
2003-07-17 13:31:39 +00:00
|
|
|
{
|
2014-11-02 19:55:22 +00:00
|
|
|
DPRINT1("Not enough memory!\n");
|
|
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
2003-07-17 13:31:39 +00:00
|
|
|
}
|
2014-11-02 19:55:22 +00:00
|
|
|
|
|
|
|
Status = ReadFileRecord(DeviceExt, Fcb->MFTIndex, FileRecord);
|
|
|
|
if (!NT_SUCCESS(Status))
|
2003-07-17 13:31:39 +00:00
|
|
|
{
|
2014-11-02 19:55:22 +00:00
|
|
|
DPRINT1("Can't find record!\n");
|
|
|
|
ExFreePoolWithTag(FileRecord, TAG_NTFS);
|
|
|
|
return Status;
|
2003-07-17 13:31:39 +00:00
|
|
|
}
|
|
|
|
|
2015-06-28 13:14:07 +00:00
|
|
|
|
|
|
|
Status = FindAttribute(DeviceExt, FileRecord, AttributeData, Fcb->Stream, wcslen(Fcb->Stream), &DataContext);
|
2014-11-02 19:55:22 +00:00
|
|
|
if (!NT_SUCCESS(Status))
|
|
|
|
{
|
[NTFS]
Totally rewrite the way MFT records attributes are handled.
Up to now, we were having really similar loops, only looking at the resident part of the attribute list, not really caring about how the loop was going.
This was leading to some issues:
- In case the attribute we were looking for was stored in the non-resident part of the attribute list, we would miss it (excepted in the case of FindAttribute() which was properly browsing the whole attribute list).
- In the specific case of FindAttribute(), one would have been able to setup a broken MFT record with the resident attribute list pointing on the non resident attribute list which itself would point to the resident attribute list. In such case, the driver would loop forever caught on the loop, allocating tones of memory. It was possible to trigger this by user space, from a non-privileged user, just by browsing the right directory entry.
- In the case of the other loops (non FindAttribute()), another issue (other than missing attributes) was present, one would have been able to setup a broken MFT record with an attribute of null-length. This would have caused the driver to loop forever on the attribute list. This could be triggered from usermode too. And could be triggered by a non-privileged user.
This commit introduces a new set of functions for attributes browsing: FindFirstAttribute(), FindNextAttribute(), FindCloseAttribute(). It allows safely browsing attributes and handles broken cases. It also performs reading of the attribute list when present and makes sure there's only one read. This method should be the only one to use to browse the attributes.
The whole NTFS code base has been converted to use this newly set of functions. This really simplifies the implementation of FindAttribute(), and prevent unsafe code duplication.
CORE-10037 #resolve #comment Fixed with r68829
svn path=/trunk/; revision=68829
2015-08-26 18:20:04 +00:00
|
|
|
NTSTATUS BrowseStatus;
|
|
|
|
FIND_ATTR_CONTXT Context;
|
2015-06-27 09:04:39 +00:00
|
|
|
PNTFS_ATTR_RECORD Attribute;
|
|
|
|
|
2015-06-28 13:14:07 +00:00
|
|
|
DPRINT1("No '%S' data stream associated with file!\n", Fcb->Stream);
|
2015-06-27 09:04:39 +00:00
|
|
|
|
[NTFS]
Totally rewrite the way MFT records attributes are handled.
Up to now, we were having really similar loops, only looking at the resident part of the attribute list, not really caring about how the loop was going.
This was leading to some issues:
- In case the attribute we were looking for was stored in the non-resident part of the attribute list, we would miss it (excepted in the case of FindAttribute() which was properly browsing the whole attribute list).
- In the specific case of FindAttribute(), one would have been able to setup a broken MFT record with the resident attribute list pointing on the non resident attribute list which itself would point to the resident attribute list. In such case, the driver would loop forever caught on the loop, allocating tones of memory. It was possible to trigger this by user space, from a non-privileged user, just by browsing the right directory entry.
- In the case of the other loops (non FindAttribute()), another issue (other than missing attributes) was present, one would have been able to setup a broken MFT record with an attribute of null-length. This would have caused the driver to loop forever on the attribute list. This could be triggered from usermode too. And could be triggered by a non-privileged user.
This commit introduces a new set of functions for attributes browsing: FindFirstAttribute(), FindNextAttribute(), FindCloseAttribute(). It allows safely browsing attributes and handles broken cases. It also performs reading of the attribute list when present and makes sure there's only one read. This method should be the only one to use to browse the attributes.
The whole NTFS code base has been converted to use this newly set of functions. This really simplifies the implementation of FindAttribute(), and prevent unsafe code duplication.
CORE-10037 #resolve #comment Fixed with r68829
svn path=/trunk/; revision=68829
2015-08-26 18:20:04 +00:00
|
|
|
BrowseStatus = FindFirstAttribute(&Context, DeviceExt, FileRecord, FALSE, &Attribute);
|
|
|
|
while (NT_SUCCESS(BrowseStatus))
|
2015-06-27 09:04:39 +00:00
|
|
|
{
|
|
|
|
if (Attribute->Type == AttributeData)
|
|
|
|
{
|
|
|
|
UNICODE_STRING Name;
|
|
|
|
|
|
|
|
Name.Length = Attribute->NameLength * sizeof(WCHAR);
|
|
|
|
Name.MaximumLength = Name.Length;
|
|
|
|
Name.Buffer = (PWCHAR)((ULONG_PTR)Attribute + Attribute->NameOffset);
|
|
|
|
DPRINT1("Data stream: '%wZ' available\n", &Name);
|
|
|
|
}
|
|
|
|
|
[NTFS]
Totally rewrite the way MFT records attributes are handled.
Up to now, we were having really similar loops, only looking at the resident part of the attribute list, not really caring about how the loop was going.
This was leading to some issues:
- In case the attribute we were looking for was stored in the non-resident part of the attribute list, we would miss it (excepted in the case of FindAttribute() which was properly browsing the whole attribute list).
- In the specific case of FindAttribute(), one would have been able to setup a broken MFT record with the resident attribute list pointing on the non resident attribute list which itself would point to the resident attribute list. In such case, the driver would loop forever caught on the loop, allocating tones of memory. It was possible to trigger this by user space, from a non-privileged user, just by browsing the right directory entry.
- In the case of the other loops (non FindAttribute()), another issue (other than missing attributes) was present, one would have been able to setup a broken MFT record with an attribute of null-length. This would have caused the driver to loop forever on the attribute list. This could be triggered from usermode too. And could be triggered by a non-privileged user.
This commit introduces a new set of functions for attributes browsing: FindFirstAttribute(), FindNextAttribute(), FindCloseAttribute(). It allows safely browsing attributes and handles broken cases. It also performs reading of the attribute list when present and makes sure there's only one read. This method should be the only one to use to browse the attributes.
The whole NTFS code base has been converted to use this newly set of functions. This really simplifies the implementation of FindAttribute(), and prevent unsafe code duplication.
CORE-10037 #resolve #comment Fixed with r68829
svn path=/trunk/; revision=68829
2015-08-26 18:20:04 +00:00
|
|
|
BrowseStatus = FindNextAttribute(&Context, &Attribute);
|
2015-06-27 09:04:39 +00:00
|
|
|
}
|
[NTFS]
Totally rewrite the way MFT records attributes are handled.
Up to now, we were having really similar loops, only looking at the resident part of the attribute list, not really caring about how the loop was going.
This was leading to some issues:
- In case the attribute we were looking for was stored in the non-resident part of the attribute list, we would miss it (excepted in the case of FindAttribute() which was properly browsing the whole attribute list).
- In the specific case of FindAttribute(), one would have been able to setup a broken MFT record with the resident attribute list pointing on the non resident attribute list which itself would point to the resident attribute list. In such case, the driver would loop forever caught on the loop, allocating tones of memory. It was possible to trigger this by user space, from a non-privileged user, just by browsing the right directory entry.
- In the case of the other loops (non FindAttribute()), another issue (other than missing attributes) was present, one would have been able to setup a broken MFT record with an attribute of null-length. This would have caused the driver to loop forever on the attribute list. This could be triggered from usermode too. And could be triggered by a non-privileged user.
This commit introduces a new set of functions for attributes browsing: FindFirstAttribute(), FindNextAttribute(), FindCloseAttribute(). It allows safely browsing attributes and handles broken cases. It also performs reading of the attribute list when present and makes sure there's only one read. This method should be the only one to use to browse the attributes.
The whole NTFS code base has been converted to use this newly set of functions. This really simplifies the implementation of FindAttribute(), and prevent unsafe code duplication.
CORE-10037 #resolve #comment Fixed with r68829
svn path=/trunk/; revision=68829
2015-08-26 18:20:04 +00:00
|
|
|
FindCloseAttribute(&Context);
|
2015-06-27 09:04:39 +00:00
|
|
|
|
2015-06-28 13:14:07 +00:00
|
|
|
ReleaseAttributeContext(DataContext);
|
2014-11-02 19:55:22 +00:00
|
|
|
ExFreePoolWithTag(FileRecord, TAG_NTFS);
|
2015-06-28 13:14:07 +00:00
|
|
|
return Status;
|
|
|
|
}
|
|
|
|
|
|
|
|
StreamSize = AttributeDataLength(&DataContext->Record);
|
|
|
|
if (ReadOffset >= StreamSize)
|
|
|
|
{
|
|
|
|
DPRINT1("Reading beyond stream end!\n");
|
|
|
|
ReleaseAttributeContext(DataContext);
|
|
|
|
ExFreePoolWithTag(FileRecord, TAG_NTFS);
|
|
|
|
return STATUS_END_OF_FILE;
|
|
|
|
}
|
|
|
|
|
|
|
|
ToRead = Length;
|
|
|
|
if (ReadOffset + Length > StreamSize)
|
|
|
|
ToRead = StreamSize - ReadOffset;
|
|
|
|
|
|
|
|
RealReadOffset = ReadOffset;
|
|
|
|
RealLength = ToRead;
|
|
|
|
|
|
|
|
if ((ReadOffset % DeviceExt->NtfsInfo.BytesPerSector) != 0 || (ToRead % DeviceExt->NtfsInfo.BytesPerSector) != 0)
|
|
|
|
{
|
|
|
|
RealReadOffset = ROUND_DOWN(ReadOffset, DeviceExt->NtfsInfo.BytesPerSector);
|
|
|
|
RealLength = ROUND_UP(ToRead, DeviceExt->NtfsInfo.BytesPerSector);
|
2016-03-27 09:33:22 +00:00
|
|
|
/* do we need to extend RealLength by one sector? */
|
|
|
|
if (RealLength + RealReadOffset < ReadOffset + Length)
|
2016-08-01 06:14:45 +00:00
|
|
|
{
|
|
|
|
if (RealReadOffset + RealLength + DeviceExt->NtfsInfo.BytesPerSector <= AttributeAllocatedLength(&DataContext->Record))
|
|
|
|
RealLength += DeviceExt->NtfsInfo.BytesPerSector;
|
|
|
|
}
|
2015-06-28 13:14:07 +00:00
|
|
|
|
2016-03-27 09:33:22 +00:00
|
|
|
|
2016-04-13 20:06:56 +00:00
|
|
|
ReadBuffer = ExAllocatePoolWithTag(NonPagedPool, RealLength, TAG_NTFS);
|
2015-06-28 13:14:07 +00:00
|
|
|
if (ReadBuffer == NULL)
|
2015-05-16 10:23:55 +00:00
|
|
|
{
|
2015-06-28 13:14:07 +00:00
|
|
|
DPRINT1("Not enough memory!\n");
|
|
|
|
ReleaseAttributeContext(DataContext);
|
|
|
|
ExFreePoolWithTag(FileRecord, TAG_NTFS);
|
|
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
2015-05-16 10:23:55 +00:00
|
|
|
}
|
2015-06-28 13:14:07 +00:00
|
|
|
AllocatedBuffer = TRUE;
|
2014-11-02 19:55:22 +00:00
|
|
|
}
|
|
|
|
|
2015-06-28 13:14:07 +00:00
|
|
|
DPRINT1("Effective read: %lu at %lu for stream '%S'\n", RealLength, RealReadOffset, Fcb->Stream);
|
2014-11-02 19:55:22 +00:00
|
|
|
RealLengthRead = ReadAttribute(DeviceExt, DataContext, RealReadOffset, (PCHAR)ReadBuffer, RealLength);
|
2015-06-28 13:14:07 +00:00
|
|
|
if (RealLengthRead == 0)
|
2014-11-02 19:55:22 +00:00
|
|
|
{
|
|
|
|
DPRINT1("Read failure!\n");
|
|
|
|
ReleaseAttributeContext(DataContext);
|
|
|
|
ExFreePoolWithTag(FileRecord, TAG_NTFS);
|
|
|
|
if (AllocatedBuffer)
|
|
|
|
{
|
|
|
|
ExFreePoolWithTag(ReadBuffer, TAG_NTFS);
|
|
|
|
}
|
|
|
|
return Status;
|
|
|
|
}
|
|
|
|
|
|
|
|
ReleaseAttributeContext(DataContext);
|
|
|
|
ExFreePoolWithTag(FileRecord, TAG_NTFS);
|
|
|
|
|
|
|
|
*LengthRead = ToRead;
|
|
|
|
|
|
|
|
DPRINT1("%lu got read\n", *LengthRead);
|
|
|
|
|
|
|
|
if (AllocatedBuffer)
|
|
|
|
{
|
|
|
|
RtlCopyMemory(Buffer, ReadBuffer + (ReadOffset - RealReadOffset), ToRead);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ToRead != Length)
|
|
|
|
{
|
|
|
|
RtlZeroMemory(Buffer + ToRead, Length - ToRead);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (AllocatedBuffer)
|
|
|
|
{
|
|
|
|
ExFreePoolWithTag(ReadBuffer, TAG_NTFS);
|
|
|
|
}
|
|
|
|
|
|
|
|
return STATUS_SUCCESS;
|
2003-07-17 13:31:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-16 12:15:06 +00:00
|
|
|
NTSTATUS
|
2015-05-10 20:35:40 +00:00
|
|
|
NtfsRead(PNTFS_IRP_CONTEXT IrpContext)
|
2003-07-17 13:31:39 +00:00
|
|
|
{
|
2013-06-16 12:15:06 +00:00
|
|
|
PDEVICE_EXTENSION DeviceExt;
|
|
|
|
PIO_STACK_LOCATION Stack;
|
|
|
|
PFILE_OBJECT FileObject;
|
|
|
|
PVOID Buffer;
|
|
|
|
ULONG ReadLength;
|
|
|
|
LARGE_INTEGER ReadOffset;
|
|
|
|
ULONG ReturnedReadLength = 0;
|
|
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
2015-05-10 20:35:40 +00:00
|
|
|
PIRP Irp;
|
|
|
|
PDEVICE_OBJECT DeviceObject;
|
2013-06-16 12:15:06 +00:00
|
|
|
|
2015-05-24 12:17:43 +00:00
|
|
|
DPRINT("NtfsRead(IrpContext %p)\n", IrpContext);
|
2013-06-16 12:15:06 +00:00
|
|
|
|
2015-05-10 20:35:40 +00:00
|
|
|
DeviceObject = IrpContext->DeviceObject;
|
|
|
|
Irp = IrpContext->Irp;
|
|
|
|
Stack = IrpContext->Stack;
|
|
|
|
FileObject = IrpContext->FileObject;
|
2013-06-16 12:15:06 +00:00
|
|
|
|
2015-05-10 20:35:40 +00:00
|
|
|
DeviceExt = DeviceObject->DeviceExtension;
|
2013-06-16 12:15:06 +00:00
|
|
|
ReadLength = Stack->Parameters.Read.Length;
|
|
|
|
ReadOffset = Stack->Parameters.Read.ByteOffset;
|
2015-05-25 17:54:27 +00:00
|
|
|
Buffer = NtfsGetUserBuffer(Irp, BooleanFlagOn(Irp->Flags, IRP_PAGING_IO));
|
2013-06-16 12:15:06 +00:00
|
|
|
|
|
|
|
Status = NtfsReadFile(DeviceExt,
|
|
|
|
FileObject,
|
|
|
|
Buffer,
|
|
|
|
ReadLength,
|
|
|
|
ReadOffset.u.LowPart,
|
|
|
|
Irp->Flags,
|
|
|
|
&ReturnedReadLength);
|
|
|
|
if (NT_SUCCESS(Status))
|
2003-07-17 13:31:39 +00:00
|
|
|
{
|
2013-06-16 12:15:06 +00:00
|
|
|
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
|
|
|
|
{
|
|
|
|
FileObject->CurrentByteOffset.QuadPart =
|
|
|
|
ReadOffset.QuadPart + ReturnedReadLength;
|
|
|
|
}
|
|
|
|
|
|
|
|
Irp->IoStatus.Information = ReturnedReadLength;
|
2003-07-17 13:31:39 +00:00
|
|
|
}
|
2013-06-16 12:15:06 +00:00
|
|
|
else
|
2003-07-17 13:31:39 +00:00
|
|
|
{
|
2013-06-16 12:15:06 +00:00
|
|
|
Irp->IoStatus.Information = 0;
|
2003-07-17 13:31:39 +00:00
|
|
|
}
|
|
|
|
|
2013-06-16 12:15:06 +00:00
|
|
|
return Status;
|
2003-07-17 13:31:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-16 12:15:06 +00:00
|
|
|
NTSTATUS
|
2015-05-24 12:17:43 +00:00
|
|
|
NtfsWrite(PNTFS_IRP_CONTEXT IrpContext)
|
2003-07-17 13:31:39 +00:00
|
|
|
{
|
2015-05-24 12:17:43 +00:00
|
|
|
DPRINT("NtfsWrite(IrpContext %p)\n",IrpContext);
|
2003-07-17 13:31:39 +00:00
|
|
|
|
2015-05-24 12:17:43 +00:00
|
|
|
IrpContext->Irp->IoStatus.Information = 0;
|
2013-06-16 12:15:06 +00:00
|
|
|
return STATUS_NOT_SUPPORTED;
|
2003-07-17 13:31:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* EOF */
|