Ros-diffs December 2017

ros-diffs@reactos.org

26 participants
355 discussions

[reactos] 03/72: [NTFS] When writing to a file, increase the file size if trying to write past the end. *FindAttribute() has been given an optional pointer to a ULONG that will receive the offset of the found attribute from the beginning of the record. This is to allow for found attributes to be written back into their file records. +SetAttributeDataLength() +UpdateFileRecord() - Updates a file record in the master file table at a given index. +AddFixupArray() - Prepares a file record or directo

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=ba33b9faac9457359efac… commit ba33b9faac9457359efac140b28cc17c7f664eb4 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Wed Jun 22 21:20:50 2016 +0000 [NTFS] When writing to a file, increase the file size if trying to write past the end. *FindAttribute() has been given an optional pointer to a ULONG that will receive the offset of the found attribute from the beginning of the record. This is to allow for found attributes to be written back into their file records. +SetAttributeDataLength() +UpdateFileRecord() - Updates a file record in the master file table at a given index. +AddFixupArray() - Prepares a file record or directory index for writing to the disk. svn path=/branches/GSoC_2016/NTFS/; revision=71660 --- drivers/filesystems/ntfs/attrib.c | 20 ++++-- drivers/filesystems/ntfs/dirctl.c | 2 +- drivers/filesystems/ntfs/fcb.c | 4 +- drivers/filesystems/ntfs/fsctl.c | 8 +-- drivers/filesystems/ntfs/mft.c | 141 +++++++++++++++++++++++++++++++++++-- drivers/filesystems/ntfs/ntfs.h | 30 +++++++- drivers/filesystems/ntfs/rw.c | 48 ++++++++++--- drivers/filesystems/ntfs/volinfo.c | 2 +- 8 files changed, 226 insertions(+), 29 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index 1883951c44..12474f6c81 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -150,6 +150,8 @@ static PNTFS_ATTR_RECORD InternalGetNextAttribute(PFIND_ATTR_CONTXT Context) { + PNTFS_ATTR_RECORD NextAttribute; + if (Context->CurrAttr == (PVOID)-1) { return NULL; @@ -165,7 +167,10 @@ InternalGetNextAttribute(PFIND_ATTR_CONTXT Context) return NULL; } - Context->CurrAttr = (PNTFS_ATTR_RECORD)((ULONG_PTR)Context->CurrAttr + Context->CurrAttr->Length); + NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)Context->CurrAttr + Context->CurrAttr->Length); + Context->Offset += ((ULONG_PTR)NextAttribute - (ULONG_PTR)Context->CurrAttr); + Context->CurrAttr = NextAttribute; + if (Context->CurrAttr < Context->LastAttr && Context->CurrAttr->Type != AttributeEnd) { @@ -186,7 +191,9 @@ InternalGetNextAttribute(PFIND_ATTR_CONTXT Context) } else if (Context->CurrAttr->Length != 0) { - Context->CurrAttr = (PNTFS_ATTR_RECORD)((ULONG_PTR)Context->CurrAttr + Context->CurrAttr->Length); + NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)Context->CurrAttr + Context->CurrAttr->Length); + Context->Offset += ((ULONG_PTR)NextAttribute - (ULONG_PTR)Context->CurrAttr); + Context->CurrAttr = NextAttribute; } else { @@ -223,6 +230,7 @@ FindFirstAttribute(PFIND_ATTR_CONTXT Context, Context->LastAttr = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + FileRecord->BytesInUse); Context->NonResidentStart = NULL; Context->NonResidentEnd = NULL; + Context->Offset = FileRecord->AttributeOffset; if (Context->FirstAttr->Type == AttributeEnd) { @@ -246,6 +254,7 @@ FindFirstAttribute(PFIND_ATTR_CONTXT Context, else { *Attribute = Context->CurrAttr; + Context->Offset = (UCHAR*)Context->CurrAttr - (UCHAR*)FileRecord; } return STATUS_SUCCESS; @@ -307,7 +316,8 @@ NtfsDumpFileNameAttribute(PNTFS_ATTR_RECORD Attribute) FileNameAttr = (PFILENAME_ATTRIBUTE)((ULONG_PTR)Attribute + Attribute->Resident.ValueOffset); DbgPrint(" (%x) '%.*S' ", FileNameAttr->NameType, FileNameAttr->NameLength, FileNameAttr->Name); - DbgPrint(" '%x' ", FileNameAttr->FileAttributes); + DbgPrint(" '%x' \n", FileNameAttr->FileAttributes); + DbgPrint(" AllocatedSize: %I64u\nDataSize: %I64u\n", FileNameAttr->AllocatedSize, FileNameAttr->DataSize); } @@ -481,8 +491,8 @@ NtfsDumpAttribute(PDEVICE_EXTENSION Vcb, { FindRun(Attribute,0,&lcn, &runcount); - DbgPrint(" AllocatedSize %I64u DataSize %I64u\n", - Attribute->NonResident.AllocatedSize, Attribute->NonResident.DataSize); + DbgPrint(" AllocatedSize %I64u DataSize %I64u InitilizedSize %I64u\n", + Attribute->NonResident.AllocatedSize, Attribute->NonResident.DataSize, Attribute->NonResident.InitializedSize); DbgPrint(" logical clusters: %I64u - %I64u\n", lcn, lcn + runcount - 1); } diff --git a/drivers/filesystems/ntfs/dirctl.c b/drivers/filesystems/ntfs/dirctl.c index 82b8a7cb1b..aaa6dfcb87 100644 --- a/drivers/filesystems/ntfs/dirctl.c +++ b/drivers/filesystems/ntfs/dirctl.c @@ -47,7 +47,7 @@ NtfsGetFileSize(PDEVICE_EXTENSION DeviceExt, NTSTATUS Status; PNTFS_ATTR_CONTEXT DataContext; - Status = FindAttribute(DeviceExt, FileRecord, AttributeData, Stream, StreamLength, &DataContext); + Status = FindAttribute(DeviceExt, FileRecord, AttributeData, Stream, StreamLength, &DataContext, NULL); if (NT_SUCCESS(Status)) { Size = AttributeDataLength(&DataContext->Record); diff --git a/drivers/filesystems/ntfs/fcb.c b/drivers/filesystems/ntfs/fcb.c index e88944c334..111660288a 100644 --- a/drivers/filesystems/ntfs/fcb.c +++ b/drivers/filesystems/ntfs/fcb.c @@ -568,7 +568,7 @@ NtfsDirFindFile(PNTFS_VCB Vcb, } else if (Colon != 0) { - Status = FindAttribute(Vcb, FileRecord, AttributeData, Colon, wcslen(Colon), &DataContext); + Status = FindAttribute(Vcb, FileRecord, AttributeData, Colon, wcslen(Colon), &DataContext, NULL); if (!NT_SUCCESS(Status)) { return STATUS_OBJECT_NAME_NOT_FOUND; @@ -741,7 +741,7 @@ NtfsReadFCBAttribute(PNTFS_VCB Vcb, return Status; } - Status = FindAttribute(Vcb, FileRecord, Type, Name, NameLength, &AttrCtxt); + Status = FindAttribute(Vcb, FileRecord, Type, Name, NameLength, &AttrCtxt, NULL); if (!NT_SUCCESS(Status)) { ExFreePoolWithTag(FileRecord, TAG_NTFS); diff --git a/drivers/filesystems/ntfs/fsctl.c b/drivers/filesystems/ntfs/fsctl.c index 0ce93a58ea..a1f3048cd0 100644 --- a/drivers/filesystems/ntfs/fsctl.c +++ b/drivers/filesystems/ntfs/fsctl.c @@ -295,7 +295,7 @@ NtfsGetVolumeData(PDEVICE_OBJECT DeviceObject, return Status; } - Status = FindAttribute(DeviceExt, DeviceExt->MasterFileTable, AttributeData, L"", 0, &DeviceExt->MFTContext); + Status = FindAttribute(DeviceExt, DeviceExt->MasterFileTable, AttributeData, L"", 0, &DeviceExt->MFTContext, NULL); if (!NT_SUCCESS(Status)) { DPRINT1("Can't find data attribute for Master File Table.\n"); @@ -333,7 +333,7 @@ NtfsGetVolumeData(PDEVICE_OBJECT DeviceObject, NtfsDumpFileAttributes(DeviceExt, VolumeRecord); /* Get volume name */ - Status = FindAttribute(DeviceExt, VolumeRecord, AttributeVolumeName, L"", 0, &AttrCtxt); + Status = FindAttribute(DeviceExt, VolumeRecord, AttributeVolumeName, L"", 0, &AttrCtxt, NULL); if (NT_SUCCESS(Status) && AttrCtxt->Record.Resident.ValueLength != 0) { @@ -374,7 +374,7 @@ NtfsGetVolumeData(PDEVICE_OBJECT DeviceObject, DeviceExt->VolumeFcb = VolumeFcb; /* Get volume information */ - Status = FindAttribute(DeviceExt, VolumeRecord, AttributeVolumeInformation, L"", 0, &AttrCtxt); + Status = FindAttribute(DeviceExt, VolumeRecord, AttributeVolumeInformation, L"", 0, &AttrCtxt, NULL); if (NT_SUCCESS(Status) && AttrCtxt->Record.Resident.ValueLength != 0) { @@ -804,7 +804,7 @@ GetVolumeBitmap(PDEVICE_EXTENSION DeviceExt, return Status; } - Status = FindAttribute(DeviceExt, BitmapRecord, AttributeData, L"", 0, &DataContext); + Status = FindAttribute(DeviceExt, BitmapRecord, AttributeData, L"", 0, &DataContext, NULL); if (!NT_SUCCESS(Status)) { DPRINT1("Failed find $DATA for bitmap: %lx\n", Status); diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 1294264e69..a53b37fb87 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -81,13 +81,24 @@ ReleaseAttributeContext(PNTFS_ATTR_CONTEXT Context) } +/** +* @name FindAttribute +* @implemented +* +* Searches a file record for an attribute matching the given type and name. +* +* @param Offset +* Optional pointer to a ULONG that will receive the offset of the found attribute +* from the beginning of the record. Can be set to NULL. +*/ NTSTATUS FindAttribute(PDEVICE_EXTENSION Vcb, PFILE_RECORD_HEADER MftRecord, ULONG Type, PCWSTR Name, ULONG NameLength, - PNTFS_ATTR_CONTEXT * AttrCtx) + PNTFS_ATTR_CONTEXT * AttrCtx, + PULONG Offset) { BOOLEAN Found; NTSTATUS Status; @@ -123,6 +134,10 @@ FindAttribute(PDEVICE_EXTENSION Vcb, /* Found it, fill up the context and return. */ DPRINT("Found context\n"); *AttrCtx = PrepareAttributeContext(Attribute); + + if (Offset != NULL) + *Offset = Context.Offset; + FindCloseAttribute(&Context); return STATUS_SUCCESS; } @@ -156,6 +171,61 @@ AttributeDataLength(PNTFS_ATTR_RECORD AttrRecord) } +NTSTATUS +SetAttributeDataLength(PFILE_OBJECT FileObject, + PNTFS_FCB Fcb, + PNTFS_ATTR_CONTEXT AttrContext, + ULONG AttrOffset, + PFILE_RECORD_HEADER FileRecord, + PDEVICE_EXTENSION DeviceExt, + PLARGE_INTEGER DataSize) +{ + if (AttrContext->Record.IsNonResident) + { + // do we need to increase the allocation size? + if (AttrContext->Record.NonResident.AllocatedSize < DataSize->QuadPart) + { + DPRINT1("FixMe: Increasing allocation size is unimplemented!\n"); + return STATUS_NOT_IMPLEMENTED; + } + + // TODO: is the file compressed, encrypted, or sparse? + + // NOTE: we need to have acquired the main resource exclusively, as well as(?) the PagingIoResource + + // TODO: update the allocated size on-disk + DPRINT("Allocated Size: %I64u\n", AttrContext->Record.NonResident.AllocatedSize); + + AttrContext->Record.NonResident.DataSize = DataSize->QuadPart; + AttrContext->Record.NonResident.InitializedSize = DataSize->QuadPart; + + Fcb->RFCB.FileSize = *DataSize; + Fcb->RFCB.ValidDataLength = *DataSize; + + DPRINT("Data Size: %I64u\n", Fcb->RFCB.FileSize.QuadPart); + + //NtfsDumpFileAttributes(Fcb->Vcb, FileRecord); + + // copy the attribute back into the FileRecord + RtlCopyMemory((PCHAR)FileRecord + AttrOffset, &AttrContext->Record, AttrContext->Record.Length); + + //NtfsDumpFileAttributes(Fcb->Vcb, FileRecord); + + // write the updated file record back to disk + UpdateFileRecord(Fcb->Vcb, Fcb->MFTIndex, FileRecord); + + CcSetFileSizes(FileObject, (PCC_FILE_SIZES)&Fcb->RFCB.AllocationSize); + } + else + { + // we can't yet handle resident attributes + DPRINT1("FixMe: Can't handle increasing length of resident attribute\n"); + return STATUS_NOT_IMPLEMENTED; + } + + return STATUS_SUCCESS; +} + ULONG ReadAttribute(PDEVICE_EXTENSION Vcb, PNTFS_ATTR_CONTEXT Context, @@ -612,8 +682,39 @@ ReadFileRecord(PDEVICE_EXTENSION Vcb, return FixupUpdateSequenceArray(Vcb, &file->Ntfs); } +/** +* UpdateFileRecord +* @implemented +* Writes a file record to the master file table, at a given index. +*/ +NTSTATUS +UpdateFileRecord(PDEVICE_EXTENSION Vcb, + ULONGLONG index, + PFILE_RECORD_HEADER file) +{ + ULONG BytesWritten; + NTSTATUS Status = STATUS_SUCCESS; + + DPRINT("UpdateFileRecord(%p, %I64x, %p)\n", Vcb, index, file); + + // Add the fixup array to prepare the data for writing to disk + AddFixupArray(Vcb, file); + + // write the file record to the master file table + Status = WriteAttribute(Vcb, Vcb->MFTContext, index * Vcb->NtfsInfo.BytesPerFileRecord, (const PUCHAR)file, Vcb->NtfsInfo.BytesPerFileRecord, &BytesWritten); + + // TODO: Update MFT mirror + + if (!NT_SUCCESS(Status)) + { + DPRINT1("UpdateFileRecord failed: %I64u written, %u expected\n", BytesWritten, Vcb->NtfsInfo.BytesPerFileRecord); + } + + return Status; +} + -NTSTATUS +NTSTATUS FixupUpdateSequenceArray(PDEVICE_EXTENSION Vcb, PNTFS_RECORD_HEADER Record) { @@ -627,6 +728,8 @@ FixupUpdateSequenceArray(PDEVICE_EXTENSION Vcb, USACount = Record->UsaCount - 1; /* Exclude the USA Number. */ Block = (USHORT*)((PCHAR)Record + Vcb->NtfsInfo.BytesPerSector - 2); + DPRINT("FixupUpdateSequenceArray(%p, %p)\nUSANumber: %u\tUSACount: %u\n", Vcb, Record, USANumber, USACount); + while (USACount) { if (*Block != USANumber) @@ -642,6 +745,36 @@ FixupUpdateSequenceArray(PDEVICE_EXTENSION Vcb, return STATUS_SUCCESS; } +NTSTATUS +AddFixupArray(PDEVICE_EXTENSION Vcb, + PFILE_RECORD_HEADER Record) +{ + USHORT *pShortToFixUp; + unsigned int ArrayEntryCount = Record->BytesAllocated / Vcb->NtfsInfo.BytesPerSector; + unsigned int Offset = Vcb->NtfsInfo.BytesPerSector - 2; + int i; + + PFIXUP_ARRAY fixupArray = (PFIXUP_ARRAY)((UCHAR*)Record + Record->Ntfs.UsaOffset); + + DPRINT("AddFixupArray(%p, %p)\n fixupArray->USN: %u, ArrayEntryCount: %u\n", Vcb, Record, fixupArray->USN, ArrayEntryCount); + + if (Record->BytesAllocated % Vcb->NtfsInfo.BytesPerSector != 0) + ArrayEntryCount++; + + fixupArray->USN++; + + for (i = 0; i < ArrayEntryCount; i++) + { + DPRINT("USN: %u\tOffset: %u\n", fixupArray->USN, Offset); + + pShortToFixUp = (USHORT*)((UCHAR*)Record + Offset); + fixupArray->Array[i] = *pShortToFixUp; + *pShortToFixUp = fixupArray->USN; + Offset += Vcb->NtfsInfo.BytesPerSector; + } + + return STATUS_SUCCESS; +} NTSTATUS ReadLCN(PDEVICE_EXTENSION Vcb, @@ -780,7 +913,7 @@ BrowseIndexEntries(PDEVICE_EXTENSION Vcb, return STATUS_OBJECT_PATH_NOT_FOUND; } - Status = FindAttribute(Vcb, MftRecord, AttributeIndexAllocation, L"$I30", 4, &IndexAllocationCtx); + Status = FindAttribute(Vcb, MftRecord, AttributeIndexAllocation, L"$I30", 4, &IndexAllocationCtx, NULL); if (!NT_SUCCESS(Status)) { DPRINT("Corrupted filesystem!\n"); @@ -850,7 +983,7 @@ NtfsFindMftRecord(PDEVICE_EXTENSION Vcb, } ASSERT(MftRecord->Ntfs.Type == NRH_FILE_TYPE); - Status = FindAttribute(Vcb, MftRecord, AttributeIndexRoot, L"$I30", 4, &IndexRootCtx); + Status = FindAttribute(Vcb, MftRecord, AttributeIndexRoot, L"$I30", 4, &IndexRootCtx, NULL); if (!NT_SUCCESS(Status)) { ExFreePoolWithTag(MftRecord, TAG_NTFS); diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index f80bb973fe..6b9a86ed07 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -483,8 +483,15 @@ typedef struct _FIND_ATTR_CONTXT PNTFS_ATTR_RECORD LastAttr; PNTFS_ATTR_RECORD NonResidentStart; PNTFS_ATTR_RECORD NonResidentEnd; + ULONG Offset; } FIND_ATTR_CONTXT, *PFIND_ATTR_CONTXT; +typedef struct +{ + USHORT USN; + USHORT Array[]; +} FIXUP_ARRAY, *PFIXUP_ARRAY; + extern PNTFS_GLOBAL_DATA NtfsGlobalData; FORCEINLINE @@ -555,7 +562,7 @@ NtfsWriteDisk(IN PDEVICE_OBJECT DeviceObject, IN LONGLONG StartingOffset, IN ULONG Length, IN ULONG SectorSize, - IN PUCHAR Buffer); + IN const PUCHAR Buffer); NTSTATUS NtfsReadSectors(IN PDEVICE_OBJECT DeviceObject, @@ -759,6 +766,15 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, ULONGLONG AttributeDataLength(PNTFS_ATTR_RECORD AttrRecord); +NTSTATUS +SetAttributeDataLength(PFILE_OBJECT FileObject, + PNTFS_FCB Fcb, + PNTFS_ATTR_CONTEXT AttrContext, + ULONG AttrOffset, + PFILE_RECORD_HEADER FileRecord, + PDEVICE_EXTENSION DeviceExt, + PLARGE_INTEGER DataSize); + ULONG AttributeAllocatedLength(PNTFS_ATTR_RECORD AttrRecord); @@ -767,13 +783,19 @@ ReadFileRecord(PDEVICE_EXTENSION Vcb, ULONGLONG index, PFILE_RECORD_HEADER file); +NTSTATUS +UpdateFileRecord(PDEVICE_EXTENSION Vcb, + ULONGLONG index, + PFILE_RECORD_HEADER file); + NTSTATUS FindAttribute(PDEVICE_EXTENSION Vcb, PFILE_RECORD_HEADER MftRecord, ULONG Type, PCWSTR Name, ULONG NameLength, - PNTFS_ATTR_CONTEXT * AttrCtx); + PNTFS_ATTR_CONTEXT * AttrCtx, + PULONG Offset); VOID ReadVCN(PDEVICE_EXTENSION Vcb, @@ -787,6 +809,10 @@ NTSTATUS FixupUpdateSequenceArray(PDEVICE_EXTENSION Vcb, PNTFS_RECORD_HEADER Record); +NTSTATUS +AddFixupArray(PDEVICE_EXTENSION Vcb, + PFILE_RECORD_HEADER Record); + NTSTATUS ReadLCN(PDEVICE_EXTENSION Vcb, ULONGLONG lcn, diff --git a/drivers/filesystems/ntfs/rw.c b/drivers/filesystems/ntfs/rw.c index 076a3e8578..5d95300ae2 100644 --- a/drivers/filesystems/ntfs/rw.c +++ b/drivers/filesystems/ntfs/rw.c @@ -95,7 +95,7 @@ NtfsReadFile(PDEVICE_EXTENSION DeviceExt, } - Status = FindAttribute(DeviceExt, FileRecord, AttributeData, Fcb->Stream, wcslen(Fcb->Stream), &DataContext); + Status = FindAttribute(DeviceExt, FileRecord, AttributeData, Fcb->Stream, wcslen(Fcb->Stream), &DataContext, NULL); if (!NT_SUCCESS(Status)) { NTSTATUS BrowseStatus; @@ -309,6 +309,7 @@ NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, PNTFS_FCB Fcb; PFILE_RECORD_HEADER FileRecord; PNTFS_ATTR_CONTEXT DataContext; + ULONG AttributeOffset; ULONGLONG StreamSize; DPRINT("NtfsWriteFile(%p, %p, %p, %u, %u, %x, %p)\n", DeviceExt, FileObject, Buffer, Length, WriteOffset, IrpFlags, LengthWritten); @@ -361,9 +362,10 @@ NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, DPRINT("Found record for %wS\n", Fcb->ObjectName); - // Find the attribute (in the NTFS sense of the word) with the data stream for our file + // Find the attribute with the data stream for our file DPRINT("Finding Data Attribute...\n"); - Status = FindAttribute(DeviceExt, FileRecord, AttributeData, Fcb->Stream, wcslen(Fcb->Stream), &DataContext); + Status = FindAttribute(DeviceExt, FileRecord, AttributeData, Fcb->Stream, wcslen(Fcb->Stream), &DataContext, + &AttributeOffset); // Did we fail to find the attribute? if (!NT_SUCCESS(Status)) @@ -405,13 +407,39 @@ NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, // Are we trying to write beyond the end of the stream? if (WriteOffset + Length > StreamSize) { - // TODO: allocate additional clusters as needed and expand stream - DPRINT1("WriteOffset: %lu\tLength: %lu\tStreamSize: %I64u\n", WriteOffset, Length, StreamSize); - DPRINT1("TODO: Stream embiggening (appending files) is not yet supported!\n"); - ReleaseAttributeContext(DataContext); - ExFreePoolWithTag(FileRecord, TAG_NTFS); - *LengthWritten = 0; // We didn't write anything - return STATUS_ACCESS_DENIED; // temporarily; we don't change file sizes yet + // is increasing the stream size allowed? + if (!(Fcb->Flags & FCB_IS_VOLUME) && + !(IrpFlags & IRP_PAGING_IO)) + { + LARGE_INTEGER DataSize; + ULONGLONG AllocationSize; + + DataSize.QuadPart = WriteOffset + Length; + + AllocationSize = ROUND_UP(DataSize.QuadPart, Fcb->Vcb->NtfsInfo.BytesPerCluster); + + // set the attribute data length + Status = SetAttributeDataLength(FileObject, Fcb, DataContext, AttributeOffset, FileRecord, DeviceExt, &DataSize); + + if (!NT_SUCCESS(Status)) + { + ReleaseAttributeContext(DataContext); + ExFreePoolWithTag(FileRecord, TAG_NTFS); + *LengthWritten = 0; + return Status; + } + + // now we need to update this file's size in every directory index entry that references it + // (saved for a later commit) + } + else + { + // TODO - just fail for now + ReleaseAttributeContext(DataContext); + ExFreePoolWithTag(FileRecord, TAG_NTFS); + *LengthWritten = 0; + return STATUS_ACCESS_DENIED; + } } DPRINT("Length: %lu\tWriteOffset: %lu\tStreamSize: %I64u\n", Length, WriteOffset, StreamSize); diff --git a/drivers/filesystems/ntfs/volinfo.c b/drivers/filesystems/ntfs/volinfo.c index ddf7f6c58d..13a3b7af7f 100644 --- a/drivers/filesystems/ntfs/volinfo.c +++ b/drivers/filesystems/ntfs/volinfo.c @@ -62,7 +62,7 @@ NtfsGetFreeClusters(PDEVICE_EXTENSION DeviceExt) return 0; } - Status = FindAttribute(DeviceExt, BitmapRecord, AttributeData, L"", 0, &DataContext); + Status = FindAttribute(DeviceExt, BitmapRecord, AttributeData, L"", 0, &DataContext, NULL); if (!NT_SUCCESS(Status)) { ExFreePoolWithTag(BitmapRecord, TAG_NTFS);

6 years, 9 months

[reactos] 02/72: [NTFS] Add fixes to WriteAttribute(): -Remove erroneous check for end of run (before writing to the last run returned) -Properly dereference RealLengthWritten pointer, as reported in CR-90

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=ea6b9622c4328b1d3c511… commit ea6b9622c4328b1d3c51196edf004febb12dd68b Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Sun Jun 12 04:02:52 2016 +0000 [NTFS] Add fixes to WriteAttribute(): -Remove erroneous check for end of run (before writing to the last run returned) -Properly dereference RealLengthWritten pointer, as reported in CR-90 svn path=/branches/GSoC_2016/NTFS/; revision=71616 --- drivers/filesystems/ntfs/mft.c | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 43b38ef2ab..1294264e69 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -517,17 +517,6 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, } else DataRunStartLCN = -1; - - if (*DataRun == 0) - { - if (Length == 0) - return STATUS_SUCCESS; - - // This code shouldn't execute, because we should have extended the allocation size - // or failed the request by now. It's just a sanity check. - DPRINT1("Encountered EOF before expected!\n"); - return STATUS_END_OF_FILE; - } } // Do we have more data to write? @@ -556,7 +545,7 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, Length -= WriteLength; SourceBuffer += WriteLength; - RealLengthWritten += WriteLength; + *RealLengthWritten += WriteLength; // We finished this request, but there's still data in this data run. if (Length == 0 && WriteLength != DataRunLength * Vcb->NtfsInfo.BytesPerCluster)

6 years, 9 months

[reactos] 01/72: [NTFS] Added minimal write support from CORE-10998 along with updates as suggested by CR-90.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=58a13831ef75324ed2b31… commit 58a13831ef75324ed2b3101c1c98ecffeabe942b Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Sun May 1 16:21:53 2016 +0000 [NTFS] Added minimal write support from CORE-10998 along with updates as suggested by CR-90. svn path=/branches/GSoC_2016/NTFS/; revision=71224 --- drivers/filesystems/ntfs/blockdev.c | 177 +++++++++++++++- drivers/filesystems/ntfs/create.c | 10 +- drivers/filesystems/ntfs/mft.c | 269 ++++++++++++++++++++++++ drivers/filesystems/ntfs/misc.c | 58 ++++++ drivers/filesystems/ntfs/ntfs.h | 30 +++ drivers/filesystems/ntfs/rw.c | 396 +++++++++++++++++++++++++++++++++++- 6 files changed, 931 insertions(+), 9 deletions(-) diff --git a/drivers/filesystems/ntfs/blockdev.c b/drivers/filesystems/ntfs/blockdev.c index 6c90131b19..1ae67e52d7 100644 --- a/drivers/filesystems/ntfs/blockdev.c +++ b/drivers/filesystems/ntfs/blockdev.c @@ -20,7 +20,8 @@ * PROJECT: ReactOS kernel * FILE: drivers/filesystem/ntfs/blockdev.c * PURPOSE: NTFS filesystem driver - * PROGRAMMER: Eric Kohl + * PROGRAMMERS: Eric Kohl + * Trevor Thompson */ /* INCLUDES *****************************************************************/ @@ -129,6 +130,180 @@ NtfsReadDisk(IN PDEVICE_OBJECT DeviceObject, return Status; } +/** +* @name NtfsWriteDisk +* @implemented +* +* Writes data from the given buffer to the given DeviceObject. +* +* @param DeviceObject +* Device to write to +* +* @param StartingOffset +* Offset, in bytes, from the start of the device object where the data will be written +* +* @param Length +* How much data will be written, in bytes +* +* @param SectorSize +* Size of the sector on the disk that the write must be aligned to +* +* @param Buffer +* The data that's being written to the device +* +* @return +* STATUS_SUCCESS in case of success, STATUS_INSUFFICIENT_RESOURCES if a memory allocation failed, +* or whatever status IoCallDriver() sets. +* +* @remarks Called by NtfsWriteFile(). May perform a read-modify-write operation if the +* requested write is not sector-aligned. +* +*/ +NTSTATUS +NtfsWriteDisk(IN PDEVICE_OBJECT DeviceObject, + IN LONGLONG StartingOffset, + IN ULONG Length, + IN ULONG SectorSize, + IN const PUCHAR Buffer) +{ + IO_STATUS_BLOCK IoStatus; + LARGE_INTEGER Offset; + KEVENT Event; + PIRP Irp; + NTSTATUS Status; + ULONGLONG RealWriteOffset; + ULONG RealLength; + BOOLEAN AllocatedBuffer = FALSE; + PUCHAR TempBuffer = NULL; + + DPRINT("NtfsWriteDisk(%p, %I64x, %u, %u, %p)\n", DeviceObject, StartingOffset, Length, SectorSize, Buffer); + + if (Length == 0) + return STATUS_SUCCESS; + + RealWriteOffset = (ULONGLONG)StartingOffset; + RealLength = Length; + + // Does the write need to be adjusted to be sector-aligned? + if ((RealWriteOffset % SectorSize) != 0 || (RealLength % SectorSize) != 0) + { + ULONGLONG relativeOffset; + + // We need to do a read-modify-write. We'll start be copying the entire + // contents of every sector that will be overwritten. + // TODO: Optimize (read no more than necessary) + + RealWriteOffset = ROUND_DOWN(StartingOffset, SectorSize); + RealLength = ROUND_UP(Length, SectorSize); + + // Would the end of our sector-aligned write fall short of the requested write? + if (RealWriteOffset + RealLength < StartingOffset + Length) + { + RealLength += SectorSize; + } + + // Did we underestimate the memory required somehow? + if (RealLength + RealWriteOffset < StartingOffset + Length) + { + DPRINT1("\a\t\t\t\t\tFIXME: calculated less memory than needed!\n"); + DPRINT1("StartingOffset: %lu\tLength: %lu\tRealWriteOffset: %lu\tRealLength: %lu\n", + StartingOffset, Length, RealWriteOffset, RealLength); + + RealLength += SectorSize; + } + + // Allocate a buffer to copy the existing data to + TempBuffer = ExAllocatePoolWithTag(NonPagedPool, RealLength, TAG_NTFS); + + // Did we fail to allocate it? + if (TempBuffer == NULL) + { + DPRINT1("Not enough memory!\n"); + + return STATUS_INSUFFICIENT_RESOURCES; + } + + // Read the sectors we'll be overwriting into TempBuffer + Status = NtfsReadDisk(DeviceObject, RealWriteOffset, RealLength, SectorSize, TempBuffer, FALSE); + + // Did we fail the read? + if (!NT_SUCCESS(Status)) + { + RtlSecureZeroMemory(TempBuffer, RealLength); + ExFreePoolWithTag(TempBuffer, TAG_NTFS); + return Status; + } + + // Calculate where the new data should be written to, relative to the start of TempBuffer + relativeOffset = StartingOffset - RealWriteOffset; + + // Modify the tempbuffer with the data being read + RtlCopyMemory(TempBuffer + relativeOffset, Buffer, Length); + + AllocatedBuffer = TRUE; + } + + // set the destination offset + Offset.QuadPart = RealWriteOffset; + + // setup the notification event for the write + KeInitializeEvent(&Event, + NotificationEvent, + FALSE); + + DPRINT("Building synchronous FSD Request...\n"); + + // Build an IRP requesting the lower-level [disk] driver to perform the write + // TODO: Forward the existing IRP instead + Irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE, + DeviceObject, + // if we allocated a temp buffer, use that instead of the Buffer parameter + ((AllocatedBuffer) ? TempBuffer : Buffer), + RealLength, + &Offset, + &Event, + &IoStatus); + // Did we fail to build the IRP? + if (Irp == NULL) + { + DPRINT1("IoBuildSynchronousFsdRequest failed\n"); + + if (AllocatedBuffer) + { + RtlSecureZeroMemory(TempBuffer, RealLength); + ExFreePoolWithTag(TempBuffer, TAG_NTFS); + } + + return STATUS_INSUFFICIENT_RESOURCES; + } + + // Call the next-lower driver to perform the write + DPRINT("Calling IO Driver with irp %p\n", Irp); + Status = IoCallDriver(DeviceObject, Irp); + + // Wait until the next-lower driver has completed the IRP + DPRINT("Waiting for IO Operation for %p\n", Irp); + if (Status == STATUS_PENDING) + { + DPRINT("Operation pending\n"); + KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL); + DPRINT("Getting IO Status... for %p\n", Irp); + Status = IoStatus.Status; + } + + if (AllocatedBuffer) + { + // zero the buffer before freeing it, so private user data can't be snooped + RtlSecureZeroMemory(TempBuffer, RealLength); + + ExFreePoolWithTag(TempBuffer, TAG_NTFS); + } + + DPRINT("NtfsWriteDisk() done (Status %x)\n", Status); + + return Status; +} + NTSTATUS NtfsReadSectors(IN PDEVICE_OBJECT DeviceObject, IN ULONG DiskSector, diff --git a/drivers/filesystems/ntfs/create.c b/drivers/filesystems/ntfs/create.c index 4a4a6a6a8d..5662806880 100644 --- a/drivers/filesystems/ntfs/create.c +++ b/drivers/filesystems/ntfs/create.c @@ -476,26 +476,26 @@ NtfsCreateFile(PDEVICE_OBJECT DeviceObject, return Status; } - /* HUGLY HACK: remain RO so far... */ + /* HUGLY HACK: Can't overwrite or supersede a file yet... */ if (RequestedDisposition == FILE_OVERWRITE || RequestedDisposition == FILE_OVERWRITE_IF || RequestedDisposition == FILE_SUPERSEDE) { - DPRINT1("Denying write request on NTFS volume\n"); + DPRINT1("Cannot yet perform an overwrite or supersede request on NTFS volume\n"); NtfsCloseFile(DeviceExt, FileObject); return STATUS_ACCESS_DENIED; } } else { - /* HUGLY HACK: remain RO so far... */ + /* HUGLY HACK: Can't create new files yet... */ if (RequestedDisposition == FILE_CREATE || RequestedDisposition == FILE_OPEN_IF || RequestedDisposition == FILE_OVERWRITE_IF || RequestedDisposition == FILE_SUPERSEDE) { - DPRINT1("Denying write request on NTFS volume\n"); - return STATUS_ACCESS_DENIED; + DPRINT1("Denying file creation request on NTFS volume\n"); + return STATUS_CANNOT_MAKE; } } diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index d02a32dc23..43b38ef2ab 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -24,6 +24,7 @@ * Valentin Verkhovsky * Pierre Schweitzer (pierre(a)reactos.org) * Hervé Poussineau (hpoussin(a)reactos.org) + * Trevor Thompson */ /* INCLUDES *****************************************************************/ @@ -31,6 +32,7 @@ #include "ntfs.h" #define NDEBUG +#undef NDEBUG #include <debug.h> /* FUNCTIONS ****************************************************************/ @@ -334,6 +336,273 @@ ReadAttribute(PDEVICE_EXTENSION Vcb, } +/** +* @name WriteAttribute +* @implemented +* +* Writes an NTFS attribute to the disk. It presently borrows a lot of code from ReadAttribute(), +* and it still needs more documentation / cleaning up. +* +* @param Vcb +* Volume Control Block indicating which volume to write the attribute to +* +* @param Context +* Pointer to an NTFS_ATTR_CONTEXT that has information about the attribute +* +* @param Offset +* Offset, in bytes, from the beginning of the attribute indicating where to start +* writing data +* +* @param Buffer +* The data that's being written to the device +* +* @param Length +* How much data will be written, in bytes +* +* @param RealLengthWritten +* Pointer to a ULONG which will receive how much data was written, in bytes +* +* @return +* STATUS_SUCCESS if successful, an error code otherwise. STATUS_NOT_IMPLEMENTED if +* writing to a sparse file. +* +* @remarks Note that in this context the word "attribute" isn't referring read-only, hidden, +* etc. - the file's data is actually stored in an attribute in NTFS parlance. +* +*/ + +NTSTATUS +WriteAttribute(PDEVICE_EXTENSION Vcb, + PNTFS_ATTR_CONTEXT Context, + ULONGLONG Offset, + const PUCHAR Buffer, + ULONG Length, + PULONG RealLengthWritten) +{ + ULONGLONG LastLCN; + PUCHAR DataRun; + LONGLONG DataRunOffset; + ULONGLONG DataRunLength; + LONGLONG DataRunStartLCN; + ULONGLONG CurrentOffset; + ULONG WriteLength; + NTSTATUS Status; + PUCHAR SourceBuffer = Buffer; + LONGLONG StartingOffset; + + DPRINT("WriteAttribute(%p, %p, %I64U, %p, %lu)\n", Vcb, Context, Offset, Buffer, Length); + + // is this a resident attribute? + if (!Context->Record.IsNonResident) + { + DPRINT1("FIXME: Writing to resident NTFS records (small files) is not supported at this time.\n"); + // (TODO: This should be really easy to implement) + + /* LeftOver code from ReadAttribute(), may be helpful: + if (Offset > Context->Record.Resident.ValueLength) + return 0; + if (Offset + Length > Context->Record.Resident.ValueLength) + Length = (ULONG)(Context->Record.Resident.ValueLength - Offset); + RtlCopyMemory(Buffer, (PCHAR)&Context->Record + Context->Record.Resident.ValueOffset + Offset, Length); + return Length;*/ + + return STATUS_NOT_IMPLEMENTED; // until we implement it + } + + // This is a non-resident attribute. + + // I. Find the corresponding start data run. + + *RealLengthWritten = 0; + + // FIXME: Cache seems to be non-working. Disable it for now + //if(Context->CacheRunOffset <= Offset && Offset < Context->CacheRunOffset + Context->CacheRunLength * Volume->ClusterSize) + /*if (0) + { + DataRun = Context->CacheRun; + LastLCN = Context->CacheRunLastLCN; + DataRunStartLCN = Context->CacheRunStartLCN; + DataRunLength = Context->CacheRunLength; + CurrentOffset = Context->CacheRunCurrentOffset; + } + else*/ + { + LastLCN = 0; + DataRun = (PUCHAR)&Context->Record + Context->Record.NonResident.MappingPairsOffset; + CurrentOffset = 0; + + while (1) + { + DataRun = DecodeRun(DataRun, &DataRunOffset, &DataRunLength); + if (DataRunOffset != -1) + { + // Normal data run. + // DPRINT1("Writing to normal data run, LastLCN %I64u DataRunOffset %I64d\n", LastLCN, DataRunOffset); + DataRunStartLCN = LastLCN + DataRunOffset; + LastLCN = DataRunStartLCN; + } + else + { + // Sparse data run. We can't support writing to sparse files yet + // (it may require increasing the allocation size). + DataRunStartLCN = -1; + DPRINT1("FIXME: Writing to sparse files is not supported yet!\n"); + return STATUS_NOT_IMPLEMENTED; + } + + // Have we reached the data run we're trying to write to? + if (Offset >= CurrentOffset && + Offset < CurrentOffset + (DataRunLength * Vcb->NtfsInfo.BytesPerCluster)) + { + break; + } + + if (*DataRun == 0) + { + // We reached the last assigned cluster + // TODO: assign new clusters to the end of the file. + // (Presently, this code will never be reached, the write should have already failed by now) + return STATUS_END_OF_FILE; + } + + CurrentOffset += DataRunLength * Vcb->NtfsInfo.BytesPerCluster; + } + } + + // II. Go through the run list and write the data + + /* REVIEWME -- As adapted from NtfsReadAttribute(): + We seem to be making a special case for the first applicable data run, but I'm not sure why. + Does it have something to do with (not) caching? Is this strategy equally applicable to writing? */ + + WriteLength = (ULONG)min(DataRunLength * Vcb->NtfsInfo.BytesPerCluster - (Offset - CurrentOffset), Length); + + StartingOffset = DataRunStartLCN * Vcb->NtfsInfo.BytesPerCluster + Offset - CurrentOffset; + + // Write the data to the disk + Status = NtfsWriteDisk(Vcb->StorageDevice, + StartingOffset, + WriteLength, + Vcb->NtfsInfo.BytesPerSector, + (PVOID)SourceBuffer); + + // Did the write fail? + if (!NT_SUCCESS(Status)) + { + Context->CacheRun = DataRun; + Context->CacheRunOffset = Offset; + Context->CacheRunStartLCN = DataRunStartLCN; + Context->CacheRunLength = DataRunLength; + Context->CacheRunLastLCN = LastLCN; + Context->CacheRunCurrentOffset = CurrentOffset; + + return Status; + } + + Length -= WriteLength; + SourceBuffer += WriteLength; + *RealLengthWritten += WriteLength; + + // Did we write to the end of the data run? + if (WriteLength == DataRunLength * Vcb->NtfsInfo.BytesPerCluster - (Offset - CurrentOffset)) + { + // Advance to the next data run + CurrentOffset += DataRunLength * Vcb->NtfsInfo.BytesPerCluster; + DataRun = DecodeRun(DataRun, &DataRunOffset, &DataRunLength); + + if (DataRunOffset != (ULONGLONG)-1) + { + DataRunStartLCN = LastLCN + DataRunOffset; + LastLCN = DataRunStartLCN; + } + else + DataRunStartLCN = -1; + + if (*DataRun == 0) + { + if (Length == 0) + return STATUS_SUCCESS; + + // This code shouldn't execute, because we should have extended the allocation size + // or failed the request by now. It's just a sanity check. + DPRINT1("Encountered EOF before expected!\n"); + return STATUS_END_OF_FILE; + } + } + + // Do we have more data to write? + while (Length > 0) + { + // Make sure we don't write past the end of the current data run + WriteLength = (ULONG)min(DataRunLength * Vcb->NtfsInfo.BytesPerCluster, Length); + + // Are we dealing with a sparse data run? + if (DataRunStartLCN == -1) + { + DPRINT1("FIXME: Don't know how to write to sparse files yet! (DataRunStartLCN == -1)\n"); + return STATUS_NOT_IMPLEMENTED; + } + else + { + // write the data to the disk + Status = NtfsWriteDisk(Vcb->StorageDevice, + DataRunStartLCN * Vcb->NtfsInfo.BytesPerCluster, + WriteLength, + Vcb->NtfsInfo.BytesPerSector, + (PVOID)SourceBuffer); + if (!NT_SUCCESS(Status)) + break; + } + + Length -= WriteLength; + SourceBuffer += WriteLength; + RealLengthWritten += WriteLength; + + // We finished this request, but there's still data in this data run. + if (Length == 0 && WriteLength != DataRunLength * Vcb->NtfsInfo.BytesPerCluster) + break; + + // Go to next run in the list. + + if (*DataRun == 0) + { + // that was the last run + if (Length > 0) + { + // Failed sanity check. + DPRINT1("Encountered EOF before expected!\n"); + return STATUS_END_OF_FILE; + } + + break; + } + + // Advance to the next data run + CurrentOffset += DataRunLength * Vcb->NtfsInfo.BytesPerCluster; + DataRun = DecodeRun(DataRun, &DataRunOffset, &DataRunLength); + if (DataRunOffset != -1) + { + // Normal data run. + DataRunStartLCN = LastLCN + DataRunOffset; + LastLCN = DataRunStartLCN; + } + else + { + // Sparse data run. + DataRunStartLCN = -1; + } + } // end while (Length > 0) [more data to write] + + Context->CacheRun = DataRun; + Context->CacheRunOffset = Offset + *RealLengthWritten; + Context->CacheRunStartLCN = DataRunStartLCN; + Context->CacheRunLength = DataRunLength; + Context->CacheRunLastLCN = LastLCN; + Context->CacheRunCurrentOffset = CurrentOffset; + + return Status; +} + NTSTATUS ReadFileRecord(PDEVICE_EXTENSION Vcb, ULONGLONG index, diff --git a/drivers/filesystems/ntfs/misc.c b/drivers/filesystems/ntfs/misc.c index ba461b04a8..76b77134c9 100644 --- a/drivers/filesystems/ntfs/misc.c +++ b/drivers/filesystems/ntfs/misc.c @@ -130,4 +130,62 @@ NtfsGetUserBuffer(PIRP Irp, } } +/** +* @name NtfsLockUserBuffer +* @implemented +* +* Ensures the IRP has an MDL Address. +* +* @param Irp +* Irp with the UserBuffer that needs locking +* +* @param Length +* Size of the Irp->UserBuffer, in bytes +* +* @param Operation +* What kind of access does the driver need to the buffer. Set to +* IoReadAccess, IoWriteAccess, or IoModifyAccess. +* +* @return +* STATUS_SUCCESS in case of success, STATUS_INSUFFICIENT_RESOURCES +* or an exception code otherwise. +* +* @remarks Trevor Thompson shamelessly ripped this from +* VfatLockUserBuffer(). Only the name was changed. +* +*/ +NTSTATUS +NtfsLockUserBuffer(IN PIRP Irp, + IN ULONG Length, + IN LOCK_OPERATION Operation) +{ + ASSERT(Irp); + + if (Irp->MdlAddress) + { + return STATUS_SUCCESS; + } + + IoAllocateMdl(Irp->UserBuffer, Length, FALSE, FALSE, Irp); + + if (!Irp->MdlAddress) + { + return STATUS_INSUFFICIENT_RESOURCES; + } + + _SEH2_TRY + { + MmProbeAndLockPages(Irp->MdlAddress, Irp->RequestorMode, Operation); + } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + IoFreeMdl(Irp->MdlAddress); + Irp->MdlAddress = NULL; + _SEH2_YIELD(return _SEH2_GetExceptionCode()); + } + _SEH2_END; + + return STATUS_SUCCESS; +} + /* EOF */ diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index 9e987c923f..f80bb973fe 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -550,6 +550,13 @@ NtfsReadDisk(IN PDEVICE_OBJECT DeviceObject, IN OUT PUCHAR Buffer, IN BOOLEAN Override); +NTSTATUS +NtfsWriteDisk(IN PDEVICE_OBJECT DeviceObject, + IN LONGLONG StartingOffset, + IN ULONG Length, + IN ULONG SectorSize, + IN PUCHAR Buffer); + NTSTATUS NtfsReadSectors(IN PDEVICE_OBJECT DeviceObject, IN ULONG DiskSector, @@ -741,6 +748,14 @@ ReadAttribute(PDEVICE_EXTENSION Vcb, PCHAR Buffer, ULONG Length); +NTSTATUS +WriteAttribute(PDEVICE_EXTENSION Vcb, + PNTFS_ATTR_CONTEXT Context, + ULONGLONG Offset, + const PUCHAR Buffer, + ULONG Length, + PULONG LengthWritten); + ULONGLONG AttributeDataLength(PNTFS_ATTR_RECORD AttrRecord); @@ -817,6 +832,21 @@ PVOID NtfsGetUserBuffer(PIRP Irp, BOOLEAN Paging); +NTSTATUS +NtfsLockUserBuffer(IN PIRP Irp, + IN ULONG Length, + IN LOCK_OPERATION Operation); + +#if 0 +BOOLEAN +wstrcmpjoki(PWSTR s1, PWSTR s2); + +VOID +CdfsSwapString(PWCHAR Out, + PUCHAR In, + ULONG Count); +#endif + VOID NtfsFileFlagsToAttributes(ULONG NtfsAttributes, PULONG FileAttributes); diff --git a/drivers/filesystems/ntfs/rw.c b/drivers/filesystems/ntfs/rw.c index 0437b61d99..076a3e8578 100644 --- a/drivers/filesystems/ntfs/rw.c +++ b/drivers/filesystems/ntfs/rw.c @@ -22,6 +22,7 @@ * PURPOSE: NTFS filesystem driver * PROGRAMMERS: Art Yerkes * Pierre Schweitzer (pierre(a)reactos.org) + * Trevor Thompson */ /* INCLUDES *****************************************************************/ @@ -255,14 +256,403 @@ NtfsRead(PNTFS_IRP_CONTEXT IrpContext) return Status; } +/** +* @name NtfsWriteFile +* @implemented +* +* Writes a file to the disk. It presently borrows a lot of code from NtfsReadFile() and +* VFatWriteFileData(). It needs some more work before it will be complete; it won't handle +* page files, asnyc io, cached writes, etc. +* +* @param DeviceExt +* Points to the target disk's DEVICE_EXTENSION +* +* @param FileObject +* Pointer to a FILE_OBJECT describing the target file +* +* @param Buffer +* The data that's being written to the file +* +* @Param Length +* The size of the data buffer being written, in bytes +* +* @param WriteOffset +* Offset, in bytes, from the beginning of the file. Indicates where to start +* writing data. +* +* @param IrpFlags +* TODO: flags are presently ignored in code. +* +* @param LengthWritten +* Pointer to a ULONG. This ULONG will be set to the number of bytes successfully written. +* +* @return +* STATUS_SUCCESS if successful, STATUS_NOT_IMPLEMENTED if a required feature isn't implemented, +* STATUS_INSUFFICIENT_RESOURCES if an allocation failed, STATUS_ACCESS_DENIED if the write itself fails, +* STATUS_PARTIAL_COPY or STATUS_UNSUCCESSFUL if ReadFileRecord() fails, or +* STATUS_OBJECT_NAME_NOT_FOUND if the file's data stream could not be found. +* +* @remarks Called by NtfsWrite(). It may perform a read-modify-write operation if the requested write is +* not sector-aligned. LengthWritten only refers to how much of the requested data has been written; +* extra data that needs to be written to make the write sector-aligned will not affect it. +* +*/ +NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, + PFILE_OBJECT FileObject, + const PUCHAR Buffer, + ULONG Length, + ULONG WriteOffset, + ULONG IrpFlags, + PULONG LengthWritten) +{ + NTSTATUS Status = STATUS_NOT_IMPLEMENTED; + PNTFS_FCB Fcb; + PFILE_RECORD_HEADER FileRecord; + PNTFS_ATTR_CONTEXT DataContext; + ULONGLONG StreamSize; + + DPRINT("NtfsWriteFile(%p, %p, %p, %u, %u, %x, %p)\n", DeviceExt, FileObject, Buffer, Length, WriteOffset, IrpFlags, LengthWritten); + + *LengthWritten = 0; + + ASSERT(DeviceExt); + + if (Length == 0) + { + if (Buffer == NULL) + return STATUS_SUCCESS; + else + return STATUS_INVALID_PARAMETER; + } + + // get the File control block + Fcb = (PNTFS_FCB)FileObject->FsContext; + ASSERT(Fcb); + + DPRINT("Fcb->PathName: %wS\n", Fcb->PathName); + DPRINT("Fcb->ObjectName: %wS\n", Fcb->ObjectName); + + // we don't yet handle compression + if (NtfsFCBIsCompressed(Fcb)) + { + DPRINT("Compressed file!\n"); + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; + } + + // allocate non-paged memory for the FILE_RECORD_HEADER + FileRecord = ExAllocatePoolWithTag(NonPagedPool, DeviceExt->NtfsInfo.BytesPerFileRecord, TAG_NTFS); + if (FileRecord == NULL) + { + DPRINT1("Not enough memory! Can't write %wS!\n", Fcb->PathName); + return STATUS_INSUFFICIENT_RESOURCES; + } + + // read the FILE_RECORD_HEADER from the drive (or cache) + DPRINT("Reading file record...\n"); + Status = ReadFileRecord(DeviceExt, Fcb->MFTIndex, FileRecord); + if (!NT_SUCCESS(Status)) + { + // We couldn't get the file's record. Free the memory and return the error + DPRINT1("Can't find record for %wS!\n", Fcb->ObjectName); + ExFreePoolWithTag(FileRecord, TAG_NTFS); + return Status; + } + + DPRINT("Found record for %wS\n", Fcb->ObjectName); + + // Find the attribute (in the NTFS sense of the word) with the data stream for our file + DPRINT("Finding Data Attribute...\n"); + Status = FindAttribute(DeviceExt, FileRecord, AttributeData, Fcb->Stream, wcslen(Fcb->Stream), &DataContext); + + // Did we fail to find the attribute? + if (!NT_SUCCESS(Status)) + { + NTSTATUS BrowseStatus; + FIND_ATTR_CONTXT Context; + PNTFS_ATTR_RECORD Attribute; + + DPRINT1("No '%S' data stream associated with file!\n", Fcb->Stream); + + // Couldn't find the requested data stream; print a list of streams available + BrowseStatus = FindFirstAttribute(&Context, DeviceExt, FileRecord, FALSE, &Attribute); + while (NT_SUCCESS(BrowseStatus)) + { + 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); + } + + BrowseStatus = FindNextAttribute(&Context, &Attribute); + } + FindCloseAttribute(&Context); + + ReleaseAttributeContext(DataContext); + ExFreePoolWithTag(FileRecord, TAG_NTFS); + return Status; + } + + // Get the size of the stream on disk + StreamSize = AttributeDataLength(&DataContext->Record); + + DPRINT("WriteOffset: %lu\tStreamSize: %I64u\n", WriteOffset, StreamSize); + + // Are we trying to write beyond the end of the stream? + if (WriteOffset + Length > StreamSize) + { + // TODO: allocate additional clusters as needed and expand stream + DPRINT1("WriteOffset: %lu\tLength: %lu\tStreamSize: %I64u\n", WriteOffset, Length, StreamSize); + DPRINT1("TODO: Stream embiggening (appending files) is not yet supported!\n"); + ReleaseAttributeContext(DataContext); + ExFreePoolWithTag(FileRecord, TAG_NTFS); + *LengthWritten = 0; // We didn't write anything + return STATUS_ACCESS_DENIED; // temporarily; we don't change file sizes yet + } + + DPRINT("Length: %lu\tWriteOffset: %lu\tStreamSize: %I64u\n", Length, WriteOffset, StreamSize); + + // Write the data to the attribute + Status = WriteAttribute(DeviceExt, DataContext, WriteOffset, Buffer, Length, LengthWritten); + + // Did the write fail? + if (!NT_SUCCESS(Status)) + { + DPRINT1("Write failure!\n"); + ReleaseAttributeContext(DataContext); + ExFreePoolWithTag(FileRecord, TAG_NTFS); + + return Status; + } + + // This should never happen: + if (*LengthWritten != Length) + { + DPRINT1("\a\tNTFS DRIVER ERROR: length written (%lu) differs from requested (%lu), but no error was indicated!\n", + *LengthWritten, Length); + Status = STATUS_UNEXPECTED_IO_ERROR; + } + + ReleaseAttributeContext(DataContext); + ExFreePoolWithTag(FileRecord, TAG_NTFS); + + return Status; +} +/** +* @name NtfsWrite +* @implemented +* +* Handles IRP_MJ_WRITE I/O Request Packets for NTFS. This code borrows a lot from +* VfatWrite, and needs a lot of cleaning up. It also needs a lot more of the code +* from VfatWrite integrated. +* +* @param IrpContext +* Points to an NTFS_IRP_CONTEXT which describes the write +* +* @return +* STATUS_SUCCESS if successful, +* STATUS_INSUFFICIENT_RESOURCES if an allocation failed, +* STATUS_INVALID_DEVICE_REQUEST if called on the main device object, +* STATUS_NOT_IMPLEMENTED or STATUS_ACCESS_DENIED if a required feature isn't implemented. +* STATUS_PARTIAL_COPY, STATUS_UNSUCCESSFUL, or STATUS_OBJECT_NAME_NOT_FOUND if NtfsWriteFile() fails. +* +* @remarks Called by NtfsDispatch() in response to an IRP_MJ_WRITE request. Page files are not implemented. +* Support for large files (>4gb) is not implemented. Cached writes, file locks, transactions, etc - not implemented. +* +*/ NTSTATUS NtfsWrite(PNTFS_IRP_CONTEXT IrpContext) { - DPRINT("NtfsWrite(IrpContext %p)\n",IrpContext); + PNTFS_FCB Fcb; + PERESOURCE Resource = NULL; + LARGE_INTEGER ByteOffset; + PUCHAR Buffer; + NTSTATUS Status = STATUS_SUCCESS; + ULONG Length = 0; + ULONG ReturnedWriteLength = 0; + PDEVICE_OBJECT DeviceObject = NULL; + PDEVICE_EXTENSION DeviceExt = NULL; + PFILE_OBJECT FileObject = NULL; + PIRP Irp = NULL; + ULONG BytesPerSector; + + DPRINT("NtfsWrite(IrpContext %p)\n", IrpContext); + ASSERT(IrpContext); + + // This request is not allowed on the main device object + if (IrpContext->DeviceObject == NtfsGlobalData->DeviceObject) + { + DPRINT1("\t\t\t\tNtfsWrite is called with the main device object.\n"); + + Irp->IoStatus.Information = 0; + return STATUS_INVALID_DEVICE_REQUEST; + } + + // get the I/O request packet + Irp = IrpContext->Irp; + + // get the File control block + Fcb = (PNTFS_FCB)IrpContext->FileObject->FsContext; + ASSERT(Fcb); + + DPRINT("About to write %wS\n", Fcb->ObjectName); + DPRINT("NTFS Version: %d.%d\n", Fcb->Vcb->NtfsInfo.MajorVersion, Fcb->Vcb->NtfsInfo.MinorVersion); + + // setup some more locals + FileObject = IrpContext->FileObject; + DeviceObject = IrpContext->DeviceObject; + DeviceExt = DeviceObject->DeviceExtension; + BytesPerSector = DeviceExt->StorageDevice->SectorSize; + Length = IrpContext->Stack->Parameters.Write.Length; + + // get the file offset we'll be writing to + ByteOffset = IrpContext->Stack->Parameters.Write.ByteOffset; + if (ByteOffset.u.LowPart == FILE_WRITE_TO_END_OF_FILE && + ByteOffset.u.HighPart == -1) + { + ByteOffset.QuadPart = Fcb->RFCB.FileSize.QuadPart; + } + + DPRINT("ByteOffset: %I64u\tLength: %lu\tBytes per sector: %lu\n", ByteOffset.QuadPart, + Length, BytesPerSector); - IrpContext->Irp->IoStatus.Information = 0; - return STATUS_NOT_SUPPORTED; + if (ByteOffset.u.HighPart && !(Fcb->Flags & FCB_IS_VOLUME)) + { + // TODO: Support large files + DPRINT1("FIXME: Writing to large files is not yet supported at this time.\n"); + return STATUS_INVALID_PARAMETER; + } + + // Is this a non-cached write? A non-buffered write? + if (IrpContext->Irp->Flags & (IRP_PAGING_IO | IRP_NOCACHE) || (Fcb->Flags & FCB_IS_VOLUME) || + IrpContext->FileObject->Flags & FILE_NO_INTERMEDIATE_BUFFERING) + { + // non-cached and non-buffered writes must be sector aligned + if (ByteOffset.u.LowPart % BytesPerSector != 0 || Length % BytesPerSector != 0) + { + DPRINT1("Non-cached writes and non-buffered writes must be sector aligned!\n"); + return STATUS_INVALID_PARAMETER; + } + } + + if (Length == 0) + { + DPRINT1("Null write!\n"); + + IrpContext->Irp->IoStatus.Information = 0; + + // FIXME: Doesn't accurately detect when a user passes NULL to WriteFile() for the buffer + if (Irp->UserBuffer == NULL && Irp->MdlAddress == NULL) + { + // FIXME: Update last write time + return STATUS_SUCCESS; + } + + return STATUS_INVALID_PARAMETER; + } + + // get the Resource + if (Fcb->Flags & FCB_IS_VOLUME) + { + Resource = &DeviceExt->DirResource; + } + else if (IrpContext->Irp->Flags & IRP_PAGING_IO) + { + Resource = &Fcb->PagingIoResource; + } + else + { + Resource = &Fcb->MainResource; + } + + // acquire exclusive access to the Resource + if (!ExAcquireResourceExclusiveLite(Resource, BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT))) + { + return STATUS_CANT_WAIT; + } + + /* From VfatWrite(). Todo: Handle file locks + if (!(IrpContext->Irp->Flags & IRP_PAGING_IO) && + FsRtlAreThereCurrentFileLocks(&Fcb->FileLock)) + { + if (!FsRtlCheckLockForWriteAccess(&Fcb->FileLock, IrpContext->Irp)) + { + Status = STATUS_FILE_LOCK_CONFLICT; + goto ByeBye; + } + }*/ + + // Is this an async request to a file? + if (!(IrpContext->Flags & IRPCONTEXT_CANWAIT) && !(Fcb->Flags & FCB_IS_VOLUME)) + { + DPRINT1("FIXME: Async writes not supported in NTFS!\n"); + + ExReleaseResourceLite(Resource); + return STATUS_NOT_IMPLEMENTED; + } + + // get the buffer of data the user is trying to write + Buffer = NtfsGetUserBuffer(Irp, BooleanFlagOn(Irp->Flags, IRP_PAGING_IO)); + ASSERT(Buffer); + + // lock the buffer + Status = NtfsLockUserBuffer(Irp, Length, IoReadAccess); + + // were we unable to lock the buffer? + if (!NT_SUCCESS(Status)) + { + DPRINT1("Unable to lock user buffer!\n"); + + ExReleaseResourceLite(Resource); + return Status; + } + + DPRINT("Existing File Size(Fcb->RFCB.FileSize.QuadPart): %I64u\n", Fcb->RFCB.FileSize.QuadPart); + DPRINT("About to write the data. Length: %lu\n", Length); + + // TODO: handle HighPart of ByteOffset (large files) + + // write the file + Status = NtfsWriteFile(DeviceExt, + FileObject, + Buffer, + Length, + ByteOffset.LowPart, + Irp->Flags, + &ReturnedWriteLength); + + IrpContext->Irp->IoStatus.Status = Status; + + // was the write successful? + if (NT_SUCCESS(Status)) + { + // TODO: Update timestamps + + if (FileObject->Flags & FO_SYNCHRONOUS_IO) + { + // advance the file pointer + FileObject->CurrentByteOffset.QuadPart = ByteOffset.QuadPart + ReturnedWriteLength; + } + + IrpContext->PriorityBoost = IO_DISK_INCREMENT; + } + else + { + DPRINT1("Write not Succesful!\tReturned length: %lu\n", ReturnedWriteLength); + } + + Irp->IoStatus.Information = ReturnedWriteLength; + + // Note: We leave the user buffer that we locked alone, it's up to the I/O manager to unlock and free it + + ExReleaseResourceLite(Resource); + + return Status; } /* EOF */

6 years, 9 months

[reactos] 01/01: [PRINTING] Fix GetPrinterW, add tests for it and GetDefaultPrinterA/W, and add a proper stub for GetPrinterDriverDirectoryA.

by Colin Finck

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=3a69fd4e966feb867fd73… commit 3a69fd4e966feb867fd730442a971041ade3965a Author: Colin Finck <colin(a)reactos.org> AuthorDate: Sun Dec 10 12:28:08 2017 +0100 [PRINTING] Fix GetPrinterW, add tests for it and GetDefaultPrinterA/W, and add a proper stub for GetPrinterDriverDirectoryA. * Pass the correct handle to _RpcGetPrinter in GetPrinterW. * Pass an empty string instead of a NULL pointer as wszComputerName to the GetPrinterLevel* functions, because this variable is later used as source for StringCbCopyExW. * Don't check for GetLastError() == ERROR_SUCCESS in tests. Windows apparently only sets the last error in case of failure. The Printing code should probably be changed similarly in a future commit. Should fix CORE-14072 --- modules/rostests/apitests/winspool/CMakeLists.txt | 1 + .../rostests/apitests/winspool/GetDefaultPrinter.c | 42 ++++++++++++-- modules/rostests/apitests/winspool/GetPrinter.c | 65 ++++++++++++++++++++++ modules/rostests/apitests/winspool/testlist.c | 8 ++- win32ss/printing/base/winspool/printerdrivers.c | 8 +++ win32ss/printing/base/winspool/printers.c | 10 +++- win32ss/printing/base/winspool/winspool.spec | 2 +- win32ss/printing/providers/localspl/printers.c | 50 +++++++++-------- 8 files changed, 155 insertions(+), 31 deletions(-) diff --git a/modules/rostests/apitests/winspool/CMakeLists.txt b/modules/rostests/apitests/winspool/CMakeLists.txt index 803d3d0c89..3a5bd52db5 100644 --- a/modules/rostests/apitests/winspool/CMakeLists.txt +++ b/modules/rostests/apitests/winspool/CMakeLists.txt @@ -4,6 +4,7 @@ list(APPEND SOURCE EnumPrinters.c EnumPrintProcessorDatatypes.c GetDefaultPrinter.c + GetPrinter.c GetPrinterData.c GetPrintProcessorDirectory.c IsValidDevmode.c diff --git a/modules/rostests/apitests/winspool/GetDefaultPrinter.c b/modules/rostests/apitests/winspool/GetDefaultPrinter.c index 728f10c24e..b40e74f5f0 100644 --- a/modules/rostests/apitests/winspool/GetDefaultPrinter.c +++ b/modules/rostests/apitests/winspool/GetDefaultPrinter.c @@ -13,7 +13,44 @@ #include <wingdi.h> #include <winspool.h> -START_TEST(GetDefaultPrinter) +START_TEST(GetDefaultPrinterA) +{ + DWORD cchDefaultPrinter; + PSTR pszDefaultPrinter; + + // Don't supply any parameters, this has to fail with ERROR_INVALID_PARAMETER. + SetLastError(0xDEADBEEF); + ok(!GetDefaultPrinterA(NULL, NULL), "GetDefaultPrinterA returns TRUE!\n"); + ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetDefaultPrinterA returns error %lu!\n", GetLastError()); + + // Determine the size of the required buffer. This has to bail out with ERROR_INSUFFICIENT_BUFFER. + cchDefaultPrinter = 0; + SetLastError(0xDEADBEEF); + ok(!GetDefaultPrinterA(NULL, &cchDefaultPrinter), "GetDefaultPrinterA returns TRUE!\n"); + ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "GetDefaultPrinterA returns error %lu!\n", GetLastError()); + + // Try with a buffer large enough. + pszDefaultPrinter = HeapAlloc(GetProcessHeap(), 0, cchDefaultPrinter); + SetLastError(0xDEADBEEF); + ok(GetDefaultPrinterA(pszDefaultPrinter, &cchDefaultPrinter), "GetDefaultPrinterA returns FALSE!\n"); + + // SetDefaultPrinterA with NULL needs to succeed and leave the default printer unchanged. + SetLastError(0xDEADBEEF); + ok(SetDefaultPrinterA(NULL), "SetDefaultPrinterA returns FALSE!\n"); + + // SetDefaultPrinterA with the previous default printer also needs to succeed. + SetLastError(0xDEADBEEF); + ok(SetDefaultPrinterA(pszDefaultPrinter), "SetDefaultPrinterA returns FALSE!\n"); + + // SetDefaultPrinterA with an invalid printer name needs to fail with ERROR_INVALID_PRINTER_NAME. + SetLastError(0xDEADBEEF); + ok(!SetDefaultPrinterA("INVALID PRINTER NAME!!!"), "SetDefaultPrinterA returns TRUE!\n"); + ok(GetLastError() == ERROR_INVALID_PRINTER_NAME, "SetDefaultPrinterA returns error %lu!\n", GetLastError()); + + HeapFree(GetProcessHeap(), 0, pszDefaultPrinter); +} + +START_TEST(GetDefaultPrinterW) { DWORD cchDefaultPrinter; PWSTR pwszDefaultPrinter; @@ -33,17 +70,14 @@ START_TEST(GetDefaultPrinter) pwszDefaultPrinter = HeapAlloc(GetProcessHeap(), 0, cchDefaultPrinter * sizeof(WCHAR)); SetLastError(0xDEADBEEF); ok(GetDefaultPrinterW(pwszDefaultPrinter, &cchDefaultPrinter), "GetDefaultPrinterW returns FALSE!\n"); - ok(GetLastError() == ERROR_SUCCESS, "GetDefaultPrinterW returns error %lu!\n", GetLastError()); // SetDefaultPrinterW with NULL needs to succeed and leave the default printer unchanged. SetLastError(0xDEADBEEF); ok(SetDefaultPrinterW(NULL), "SetDefaultPrinterW returns FALSE!\n"); - ok(GetLastError() == ERROR_SUCCESS, "SetDefaultPrinterW returns error %lu!\n", GetLastError()); // SetDefaultPrinterW with the previous default printer also needs to succeed. SetLastError(0xDEADBEEF); ok(SetDefaultPrinterW(pwszDefaultPrinter), "SetDefaultPrinterW returns FALSE!\n"); - ok(GetLastError() == ERROR_SUCCESS, "SetDefaultPrinterW returns error %lu!\n", GetLastError()); // SetDefaultPrinterW with an invalid printer name needs to fail with ERROR_INVALID_PRINTER_NAME. SetLastError(0xDEADBEEF); diff --git a/modules/rostests/apitests/winspool/GetPrinter.c b/modules/rostests/apitests/winspool/GetPrinter.c new file mode 100644 index 0000000000..608f8f5a51 --- /dev/null +++ b/modules/rostests/apitests/winspool/GetPrinter.c @@ -0,0 +1,65 @@ +/* + * PROJECT: ReactOS Print Spooler DLL API Tests + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: Tests for GetPrinterA/GetPrinterW + * COPYRIGHT: Copyright 2017 Colin Finck (colin(a)reactos.org) + */ + +#include <apitest.h> + +#define WIN32_NO_STATUS +#include <windef.h> +#include <winbase.h> +#include <wingdi.h> +#include <winspool.h> + +/* From printing/include/spoolss.h */ +#define MAX_PRINTER_NAME 220 + +START_TEST(GetPrinter) +{ + DWORD cbNeeded; + DWORD cbTemp; + DWORD cchDefaultPrinter; + DWORD Level; + HANDLE hPrinter; + PVOID pMem; + WCHAR wszDefaultPrinter[MAX_PRINTER_NAME + 1]; + + // Open a handle to the default printer. + cchDefaultPrinter = _countof(wszDefaultPrinter); + ok(GetDefaultPrinterW(wszDefaultPrinter, &cchDefaultPrinter), "GetDefaultPrinterW returns FALSE and requires %lu characters!\n", cchDefaultPrinter); + if (!OpenPrinterW(wszDefaultPrinter, &hPrinter, NULL)) + { + skip("Could not retrieve a handle to the default printer!\n"); + return; + } + + // Try for all levels. Level 0 is valid here and returns the PRINTER_INFO_STRESS structure (documented in MS-RPRN). + for (Level = 0; Level <= 9; Level++) + { + // Try with no valid arguments at all. + SetLastError(0xDEADBEEF); + ok(!GetPrinterW(NULL, Level, NULL, 0, NULL), "GetPrinterW returns TRUE for Level %lu!\n", Level); + ok(GetLastError() == ERROR_INVALID_HANDLE, "GetPrinterW returns error %lu for Level %lu!\n", GetLastError(), Level); + + // Now supply at least a handle. + SetLastError(0xDEADBEEF); + ok(!GetPrinterW(hPrinter, Level, NULL, 0, NULL), "GetPrinterW returns TRUE for Level %lu!\n", Level); + ok(GetLastError() == RPC_X_NULL_REF_POINTER, "GetPrinterW returns error %lu for Level %lu!\n", GetLastError(), Level); + + // Now get the buffer size. + SetLastError(0xDEADBEEF); + ok(!GetPrinterW(hPrinter, Level, NULL, 0, &cbNeeded), "GetPrinterW returns TRUE for Level %lu!\n", Level); + ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "GetPrinterW returns error %lu for Level %lu!\n", GetLastError(), Level); + + // Finally use the function as intended and aim for success! + pMem = HeapAlloc(GetProcessHeap(), 0, cbNeeded); + SetLastError(0xDEADBEEF); + ok(GetPrinterW(hPrinter, Level, pMem, cbNeeded, &cbTemp), "GetPrinterW returns FALSE for Level %lu!\n", Level); + ok(cbNeeded == cbTemp, "cbNeeded is %lu, reference size is %lu for Level %lu!\n", cbNeeded, cbTemp, Level); + HeapFree(GetProcessHeap(), 0, pMem); + } + + ClosePrinter(hPrinter); +} diff --git a/modules/rostests/apitests/winspool/testlist.c b/modules/rostests/apitests/winspool/testlist.c index e08bffdd32..445de7a6e1 100644 --- a/modules/rostests/apitests/winspool/testlist.c +++ b/modules/rostests/apitests/winspool/testlist.c @@ -13,7 +13,9 @@ extern void func_ClosePrinter(void); extern void func_EnumPrinters(void); extern void func_EnumPrintProcessorDatatypes(void); -extern void func_GetDefaultPrinter(void); +extern void func_GetDefaultPrinterA(void); +extern void func_GetDefaultPrinterW(void); +extern void func_GetPrinter(void); extern void func_GetPrinterData(void); extern void func_GetPrintProcessorDirectoryA(void); extern void func_GetPrintProcessorDirectoryW(void); @@ -27,7 +29,9 @@ const struct test winetest_testlist[] = { "ClosePrinter", func_ClosePrinter }, { "EnumPrinters", func_EnumPrinters }, { "EnumPrintProcessorDatatypes", func_EnumPrintProcessorDatatypes }, - { "GetDefaultPrinter", func_GetDefaultPrinter }, + { "GetDefaultPrinterA", func_GetDefaultPrinterA }, + { "GetDefaultPrinterW", func_GetDefaultPrinterW }, + { "GetPrinter", func_GetPrinter }, { "GetPrinterData", func_GetPrinterData }, { "GetPrintProcessorDirectoryA", func_GetPrintProcessorDirectoryA }, { "GetPrintProcessorDirectoryW", func_GetPrintProcessorDirectoryW }, diff --git a/win32ss/printing/base/winspool/printerdrivers.c b/win32ss/printing/base/winspool/printerdrivers.c index de87781085..07ba18c131 100644 --- a/win32ss/printing/base/winspool/printerdrivers.c +++ b/win32ss/printing/base/winspool/printerdrivers.c @@ -87,6 +87,14 @@ EnumPrinterDriversW(PWSTR pName, PWSTR pEnvironment, DWORD Level, PBYTE pDriverI return FALSE; } +BOOL WINAPI +GetPrinterDriverDirectoryA(PSTR pName, PSTR pEnvironment, DWORD Level, PBYTE pDriverDirectory, DWORD cbBuf, PDWORD pcbNeeded) +{ + TRACE("GetPrinterDriverDirectoryA(%s, %s, %lu, %p, %lu, %p)\n", pName, pEnvironment, Level, pDriverDirectory, cbBuf, pcbNeeded); + UNIMPLEMENTED; + return FALSE; +} + BOOL WINAPI GetPrinterDriverDirectoryW(PWSTR pName, PWSTR pEnvironment, DWORD Level, PBYTE pDriverDirectory, DWORD cbBuf, PDWORD pcbNeeded) { diff --git a/win32ss/printing/base/winspool/printers.c b/win32ss/printing/base/winspool/printers.c index ffe1823089..471db1339e 100644 --- a/win32ss/printing/base/winspool/printers.c +++ b/win32ss/printing/base/winspool/printers.c @@ -630,9 +630,17 @@ BOOL WINAPI GetPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter, DWORD cbBuf, LPDWORD pcbNeeded) { DWORD dwErrorCode; + PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter; TRACE("GetPrinterW(%p, %lu, %p, %lu, %p)\n", hPrinter, Level, pPrinter, cbBuf, pcbNeeded); + // Sanity checks. + if (!pHandle) + { + dwErrorCode = ERROR_INVALID_HANDLE; + goto Cleanup; + } + // Dismiss invalid levels already at this point. if (Level > 9) { @@ -646,7 +654,7 @@ GetPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter, DWORD cbBuf, LPDWORD // Do the RPC call RpcTryExcept { - dwErrorCode = _RpcGetPrinter(hPrinter, Level, pPrinter, cbBuf, pcbNeeded); + dwErrorCode = _RpcGetPrinter(pHandle->hPrinter, Level, pPrinter, cbBuf, pcbNeeded); } RpcExcept(EXCEPTION_EXECUTE_HANDLER) { diff --git a/win32ss/printing/base/winspool/winspool.spec b/win32ss/printing/base/winspool/winspool.spec index 5d8fed463e..7c2888b236 100644 --- a/win32ss/printing/base/winspool/winspool.spec +++ b/win32ss/printing/base/winspool/winspool.spec @@ -152,7 +152,7 @@ 251 stdcall GetPrinterDataExW(ptr wstr wstr ptr ptr long ptr) 252 stdcall GetPrinterDataW(ptr wstr ptr ptr long ptr) 253 stdcall GetPrinterDriverA(ptr str long ptr long ptr) -254 stdcall -stub GetPrinterDriverDirectoryA(str str long ptr long ptr) +254 stdcall GetPrinterDriverDirectoryA(str str long ptr long ptr) 255 stdcall GetPrinterDriverDirectoryW(wstr wstr long ptr long ptr) 256 stdcall GetPrinterDriverW(ptr wstr long ptr long ptr) 257 stdcall GetPrinterW(ptr long ptr long ptr) diff --git a/win32ss/printing/providers/localspl/printers.c b/win32ss/printing/providers/localspl/printers.c index 022fd39a3e..7c9c2dd3b5 100644 --- a/win32ss/printing/providers/localspl/printers.c +++ b/win32ss/printing/providers/localspl/printers.c @@ -11,19 +11,19 @@ SKIPLIST PrinterList; // Forward Declarations -static void _LocalGetPrinterLevel0(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_STRESS* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName); -static void _LocalGetPrinterLevel1(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_1W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName); -static void _LocalGetPrinterLevel2(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_2W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName); -static void _LocalGetPrinterLevel3(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_3* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName); -static void _LocalGetPrinterLevel4(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_4W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName); -static void _LocalGetPrinterLevel5(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_5W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName); -static void _LocalGetPrinterLevel6(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_6* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName); -static void _LocalGetPrinterLevel7(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_7W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName); -static void _LocalGetPrinterLevel8(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_8W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName); -static void _LocalGetPrinterLevel9(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_9W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName); +static void _LocalGetPrinterLevel0(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_STRESS* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName); +static void _LocalGetPrinterLevel1(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_1W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName); +static void _LocalGetPrinterLevel2(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_2W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName); +static void _LocalGetPrinterLevel3(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_3* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName); +static void _LocalGetPrinterLevel4(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_4W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName); +static void _LocalGetPrinterLevel5(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_5W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName); +static void _LocalGetPrinterLevel6(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_6* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName); +static void _LocalGetPrinterLevel7(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_7W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName); +static void _LocalGetPrinterLevel8(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_8W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName); +static void _LocalGetPrinterLevel9(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_9W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName); // Local Constants -typedef void (*PLocalGetPrinterLevelFunc)(PLOCAL_PRINTER, PVOID, PBYTE*, PDWORD, DWORD, PWSTR); +typedef void (*PLocalGetPrinterLevelFunc)(PLOCAL_PRINTER, PVOID, PBYTE*, PDWORD, DWORD, PCWSTR); static const PLocalGetPrinterLevelFunc pfnGetPrinterLevels[] = { (PLocalGetPrinterLevelFunc)&_LocalGetPrinterLevel0, @@ -488,7 +488,7 @@ _DumpLevel1PrintProviderInformation(PBYTE pPrinterEnum, DWORD cbBuf, PDWORD pcbN } static void -_LocalGetPrinterLevel0(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_STRESS* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName) +_LocalGetPrinterLevel0(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_STRESS* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName) { size_t cbName; PWSTR p; @@ -535,7 +535,7 @@ _LocalGetPrinterLevel0(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_STRESS* ppPrinterI } static void -_LocalGetPrinterLevel1(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_1W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName) +_LocalGetPrinterLevel1(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_1W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName) { const WCHAR wszComma[] = L","; @@ -590,7 +590,7 @@ _LocalGetPrinterLevel1(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_1W* ppPrinterInfo, } static void -_LocalGetPrinterLevel2(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_2W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName) +_LocalGetPrinterLevel2(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_2W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName) { WCHAR wszEmpty[] = L""; @@ -682,7 +682,7 @@ _LocalGetPrinterLevel2(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_2W* ppPrinterInfo, } static void -_LocalGetPrinterLevel3(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_3* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName) +_LocalGetPrinterLevel3(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_3* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName) { SECURITY_DESCRIPTOR SecurityDescriptor = { 0 }; @@ -704,7 +704,7 @@ _LocalGetPrinterLevel3(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_3* ppPrinterInfo, } static void -_LocalGetPrinterLevel4(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_4W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName) +_LocalGetPrinterLevel4(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_4W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName) { size_t cbPrinterName; PWSTR p; @@ -738,7 +738,7 @@ _LocalGetPrinterLevel4(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_4W* ppPrinterInfo, } static void -_LocalGetPrinterLevel5(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_5W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName) +_LocalGetPrinterLevel5(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_5W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName) { size_t cbPrinterName; size_t cbPortName; @@ -779,7 +779,7 @@ _LocalGetPrinterLevel5(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_5W* ppPrinterInfo, } static void -_LocalGetPrinterLevel6(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_6* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName) +_LocalGetPrinterLevel6(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_6* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName) { if (!ppPrinterInfo) { @@ -795,7 +795,7 @@ _LocalGetPrinterLevel6(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_6* ppPrinterInfo, } static void -_LocalGetPrinterLevel7(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_7W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName) +_LocalGetPrinterLevel7(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_7W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName) { if (!ppPrinterInfo) { @@ -814,7 +814,7 @@ _LocalGetPrinterLevel7(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_7W* ppPrinterInfo, } static void -_LocalGetPrinterLevel8(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_8W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName) +_LocalGetPrinterLevel8(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_8W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName) { DWORD cbDevMode; @@ -837,7 +837,7 @@ _LocalGetPrinterLevel8(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_8W* ppPrinterInfo, } static void -_LocalGetPrinterLevel9(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_9W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName) +_LocalGetPrinterLevel9(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_9W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PCWSTR wszComputerName) { DWORD cbDevMode; @@ -965,6 +965,10 @@ Cleanup: BOOL WINAPI LocalGetPrinter(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter, DWORD cbBuf, LPDWORD pcbNeeded) { + // We never prepend a Computer Name to the output, but need to provide an empty string, + // because this variable is passed to StringCbCopyExW. + const WCHAR wszDummyComputerName[] = L""; + DWORD dwErrorCode; PBYTE pPrinterEnd; PLOCAL_HANDLE pHandle = (PLOCAL_HANDLE)hPrinter; @@ -997,7 +1001,7 @@ LocalGetPrinter(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter, DWORD cbBuf, LPDW // Count the required buffer size. *pcbNeeded = 0; - pfnGetPrinterLevels[Level](pPrinterHandle->pPrinter, NULL, NULL, pcbNeeded, 0, NULL); + pfnGetPrinterLevels[Level](pPrinterHandle->pPrinter, NULL, NULL, pcbNeeded, 0, wszDummyComputerName); // Check if the supplied buffer is large enough. if (cbBuf < *pcbNeeded) @@ -1008,7 +1012,7 @@ LocalGetPrinter(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter, DWORD cbBuf, LPDW // Copy over the Printer information. pPrinterEnd = &pPrinter[*pcbNeeded]; - pfnGetPrinterLevels[Level](pPrinterHandle->pPrinter, &pPrinter, &pPrinterEnd, NULL, 0, NULL); + pfnGetPrinterLevels[Level](pPrinterHandle->pPrinter, &pPrinter, &pPrinterEnd, NULL, 0, wszDummyComputerName); dwErrorCode = ERROR_SUCCESS; Cleanup:

6 years, 9 months

[reactos] 01/01: [USETUP] LanguageList => MUILanguageList. #179

by Amine Khaldi

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=3449296f7bc910db69a80… commit 3449296f7bc910db69a80f782d4a86b8f0eea9b7 Author: Amine Khaldi <amine.khaldi(a)reactos.org> AuthorDate: Sat Dec 9 23:33:02 2017 +0100 [USETUP] LanguageList => MUILanguageList. #179 --- base/setup/usetup/mui.c | 44 ++++++++++++++++++++-------------------- base/setup/usetup/muilanguages.h | 2 +- 2 files changed, 23 insertions(+), 23 deletions(-) diff --git a/base/setup/usetup/mui.c b/base/setup/usetup/mui.c index 8a9df44b30..0ddbdfebbb 100644 --- a/base/setup/usetup/mui.c +++ b/base/setup/usetup/mui.c @@ -52,13 +52,13 @@ FindLanguageIndex(VOID) do { - if (_wcsicmp(LanguageList[lngIndex].LanguageID , SelectedLanguageId) == 0) + if (_wcsicmp(MUILanguageList[lngIndex].LanguageID , SelectedLanguageId) == 0) { return lngIndex; } lngIndex++; - }while (LanguageList[lngIndex].MuiPages != NULL); + } while (MUILanguageList[lngIndex].MuiPages != NULL); return 0; } @@ -72,11 +72,11 @@ IsLanguageAvailable( do { - if (_wcsicmp(LanguageList[lngIndex].LanguageID , LanguageId) == 0) + if (_wcsicmp(MUILanguageList[lngIndex].LanguageID , LanguageId) == 0) return TRUE; lngIndex++; - }while (LanguageList[lngIndex].MuiPages != NULL); + } while (MUILanguageList[lngIndex].MuiPages != NULL); return FALSE; } @@ -92,7 +92,7 @@ FindMUIEntriesOfPage( const MUI_PAGE * Pages = NULL; lngIndex = max(FindLanguageIndex(), 0); - Pages = LanguageList[lngIndex].MuiPages; + Pages = MUILanguageList[lngIndex].MuiPages; do { @@ -111,7 +111,7 @@ const MUI_ERROR * FindMUIErrorEntries(VOID) { ULONG lngIndex = max(FindLanguageIndex(), 0); - return LanguageList[lngIndex].MuiErrors; + return MUILanguageList[lngIndex].MuiErrors; } @@ -120,7 +120,7 @@ const MUI_STRING * FindMUIStringEntries(VOID) { ULONG lngIndex = max(FindLanguageIndex(), 0); - return LanguageList[lngIndex].MuiStrings; + return MUILanguageList[lngIndex].MuiStrings; } @@ -128,7 +128,7 @@ LPCWSTR MUIDefaultKeyboardLayout(VOID) { ULONG lngIndex = max(FindLanguageIndex(), 0); - return LanguageList[lngIndex].MuiLayouts[0].LayoutID; + return MUILanguageList[lngIndex].MuiLayouts[0].LayoutID; } @@ -136,7 +136,7 @@ PWCHAR MUIGetGeoID(VOID) { ULONG lngIndex = max(FindLanguageIndex(), 0); - return LanguageList[lngIndex].GeoID; + return MUILanguageList[lngIndex].GeoID; } @@ -144,7 +144,7 @@ const MUI_LAYOUTS * MUIGetLayoutsList(VOID) { ULONG lngIndex = max(FindLanguageIndex(), 0); - return LanguageList[lngIndex].MuiLayouts; + return MUILanguageList[lngIndex].MuiLayouts; } @@ -549,14 +549,14 @@ AddKeyboardLayouts(VOID) do { - if (_wcsicmp(LanguageList[lngIndex].LanguageID , SelectedLanguageId) == 0) + if (_wcsicmp(MUILanguageList[lngIndex].LanguageID , SelectedLanguageId) == 0) { - return AddKbLayoutsToRegistry(LanguageList[lngIndex].MuiLayouts); + return AddKbLayoutsToRegistry(MUILanguageList[lngIndex].MuiLayouts); } lngIndex++; } - while (LanguageList[lngIndex].MuiPages != NULL); + while (MUILanguageList[lngIndex].MuiPages != NULL); return FALSE; } @@ -703,12 +703,12 @@ AddCodePage(VOID) ULONG lngIndex = 0; do { - if (_wcsicmp(LanguageList[lngIndex].LanguageID , SelectedLanguageId) == 0) + if (_wcsicmp(MUILanguageList[lngIndex].LanguageID , SelectedLanguageId) == 0) { - if (AddCodepageToRegistry(LanguageList[lngIndex].ACPage, - LanguageList[lngIndex].OEMCPage, - LanguageList[lngIndex].MACCPage)&& - AddFontsSettingsToRegistry(LanguageList[lngIndex].MuiSubFonts)) + if (AddCodepageToRegistry(MUILanguageList[lngIndex].ACPage, + MUILanguageList[lngIndex].OEMCPage, + MUILanguageList[lngIndex].MACCPage)&& + AddFontsSettingsToRegistry(MUILanguageList[lngIndex].MuiSubFonts)) { return TRUE; } @@ -720,7 +720,7 @@ AddCodePage(VOID) lngIndex++; } - while (LanguageList[lngIndex].MuiPages != NULL); + while (MUILanguageList[lngIndex].MuiPages != NULL); return FALSE; } @@ -734,16 +734,16 @@ SetConsoleCodePage(VOID) do { - if (_wcsicmp(LanguageList[lngIndex].LanguageID , SelectedLanguageId) == 0) + if (_wcsicmp(MUILanguageList[lngIndex].LanguageID , SelectedLanguageId) == 0) { - wCodePage = (UINT) wcstoul(LanguageList[lngIndex].OEMCPage, NULL, 10); + wCodePage = (UINT) wcstoul(MUILanguageList[lngIndex].OEMCPage, NULL, 10); SetConsoleOutputCP(wCodePage); return; } lngIndex++; } - while (LanguageList[lngIndex].MuiPages != NULL); + while (MUILanguageList[lngIndex].MuiPages != NULL); } /* EOF */ diff --git a/base/setup/usetup/muilanguages.h b/base/setup/usetup/muilanguages.h index d0505caeab..dcb00a2cc4 100644 --- a/base/setup/usetup/muilanguages.h +++ b/base/setup/usetup/muilanguages.h @@ -411,7 +411,7 @@ #include "lang/zh-TW.h" #endif -const MUI_LANGUAGE LanguageList[] = +const MUI_LANGUAGE MUILanguageList[] = { /* Lang ID, ANSI CP, OEM CP, MAC CP, Language Name, GeoID page strgs,error strings, other strings, fonts, kb layouts */ #ifdef LANGUAGE_AF_ZA

6 years, 9 months

[reactos] 01/01: [ITSS] Get the stubs file out of the source files list. #179

by Amine Khaldi

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=1c4f4818ea3fbadec28ca… commit 1c4f4818ea3fbadec28caa4bfcba6ac3e828a32f Author: Amine Khaldi <amine.khaldi(a)reactos.org> AuthorDate: Sat Dec 9 23:21:04 2017 +0100 [ITSS] Get the stubs file out of the source files list. #179 --- dll/win32/itss/CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dll/win32/itss/CMakeLists.txt b/dll/win32/itss/CMakeLists.txt index d45b8dd4a8..0dbf58025d 100644 --- a/dll/win32/itss/CMakeLists.txt +++ b/dll/win32/itss/CMakeLists.txt @@ -10,13 +10,13 @@ list(APPEND SOURCE moniker.c protocol.c storage.c - precomp.h - ${CMAKE_CURRENT_BINARY_DIR}/itss_stubs.c) + precomp.h) add_library(itss SHARED ${SOURCE} guid.c rsrc.rc + ${CMAKE_CURRENT_BINARY_DIR}/itss_stubs.c ${CMAKE_CURRENT_BINARY_DIR}/itss.def) set_module_type(itss win32dll)

6 years, 9 months

[reactos] 01/01: [FASTFAT] Fix FastFAT not returning short name for FAT volumes in FileBothDirectoryInformation case This is likely due to a copy paste error where long name was copied twice and short never. Fun fact: this was not affecting FATX volumes Fun fact2: this was defeating a buffer overflow check and thus was allowing buffer overflow!

by Pierre Schweitzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=18d6584da443c23b1b139… commit 18d6584da443c23b1b139d6995007781b495e868 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Sat Dec 9 21:22:55 2017 +0100 [FASTFAT] Fix FastFAT not returning short name for FAT volumes in FileBothDirectoryInformation case This is likely due to a copy paste error where long name was copied twice and short never. Fun fact: this was not affecting FATX volumes Fun fact2: this was defeating a buffer overflow check and thus was allowing buffer overflow! CORE-14088 --- drivers/filesystems/fastfat/dir.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/drivers/filesystems/fastfat/dir.c b/drivers/filesystems/fastfat/dir.c index 51359c4966..dd53080cda 100644 --- a/drivers/filesystems/fastfat/dir.c +++ b/drivers/filesystems/fastfat/dir.c @@ -427,9 +427,10 @@ VfatGetFileBothInformation( { pInfo->ShortNameLength = (CCHAR)DirContext->ShortNameU.Length; - RtlCopyMemory(pInfo->FileName, - DirContext->LongNameU.Buffer, - DirContext->LongNameU.Length); + ASSERT(pInfo->ShortNameLength / sizeof(WCHAR) <= 12); + RtlCopyMemory(pInfo->ShortName, + DirContext->ShortNameU.Buffer, + DirContext->ShortNameU.Length); /* pInfo->FileIndex = ; */

6 years, 9 months

[reactos] 02/02: [CHKDSK] Don't continue repair if volume is in use This makes use of previous commit vfatlib improvements that allow caller to stop chkdsk if locking fail, which will happen if volume is in use. That way, ReactOS users won't be able any longer to f*** up their C:\ volume by attempting to chkdsk -f it!

by Pierre Schweitzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=48250aef6e1fbc00822b3… commit 48250aef6e1fbc00822b338322f8d5fe050fe138 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Sat Dec 9 21:10:32 2017 +0100 [CHKDSK] Don't continue repair if volume is in use This makes use of previous commit vfatlib improvements that allow caller to stop chkdsk if locking fail, which will happen if volume is in use. That way, ReactOS users won't be able any longer to f*** up their C:\ volume by attempting to chkdsk -f it! CORE-14087 --- base/system/chkdsk/chkdsk.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/base/system/chkdsk/chkdsk.c b/base/system/chkdsk/chkdsk.c index 57a7b26aef..76dc975098 100644 --- a/base/system/chkdsk/chkdsk.c +++ b/base/system/chkdsk/chkdsk.c @@ -228,6 +228,7 @@ ChkdskCallback( DWORD Modifier, PVOID Argument) { + BOOLEAN Ret; PDWORD percent; PBOOLEAN status; PTEXTOUTPUT output; @@ -236,6 +237,7 @@ ChkdskCallback( // We get other types of commands, // but we don't have to pay attention to them // + Ret = TRUE; switch (Command) { case UNKNOWN2: @@ -259,7 +261,8 @@ ChkdskCallback( break; case VOLUMEINUSE: - ConPuts(StdOut, L"VOLUMEINUSE\n"); + ConPuts(StdOut, L"Volume is in use and cannot be locked\n"); + Ret = FALSE; break; case UNKNOWN9: @@ -313,7 +316,7 @@ ChkdskCallback( } break; } - return TRUE; + return Ret; } #ifndef FMIFS_IMPORT_DLL

6 years, 9 months

[reactos] 01/02: [VFATLIB] Make Chkdsk handle volume opening locking failures. For instance, when repair is required, we can ask the caller whether we should continue or not in case locking failed. Also, introduced a hack for 1st stage where IopParseDevice() hack is in usage so that broken NTSTATUS is diverted to appropriate status. That way, usetup will properly continue even if locking failed (due to its callback stub!)

by Pierre Schweitzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=6a224a38a15bd3b02ce3b… commit 6a224a38a15bd3b02ce3b20eef3a3f2ccf68ab96 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Sat Dec 9 21:07:09 2017 +0100 [VFATLIB] Make Chkdsk handle volume opening locking failures. For instance, when repair is required, we can ask the caller whether we should continue or not in case locking failed. Also, introduced a hack for 1st stage where IopParseDevice() hack is in usage so that broken NTSTATUS is diverted to appropriate status. That way, usetup will properly continue even if locking failed (due to its callback stub!) CORE-14087 --- sdk/lib/fslib/vfatlib/check/io.c | 18 +++++++++++++++--- sdk/lib/fslib/vfatlib/check/io.h | 2 +- sdk/lib/fslib/vfatlib/vfatlib.c | 16 +++++++++++++++- 3 files changed, 31 insertions(+), 5 deletions(-) diff --git a/sdk/lib/fslib/vfatlib/check/io.c b/sdk/lib/fslib/vfatlib/check/io.c index 17db7a1c8e..2eca2abdd4 100644 --- a/sdk/lib/fslib/vfatlib/check/io.c +++ b/sdk/lib/fslib/vfatlib/check/io.c @@ -159,7 +159,7 @@ static off_t WIN32lseek(HANDLE fd, off_t offset, int whence) /******************************************************************************/ -void fs_open(PUNICODE_STRING DriveRoot, int read_write) +NTSTATUS fs_open(PUNICODE_STRING DriveRoot, int read_write) { NTSTATUS Status; OBJECT_ATTRIBUTES ObjectAttributes; @@ -180,11 +180,14 @@ void fs_open(PUNICODE_STRING DriveRoot, int read_write) if (!NT_SUCCESS(Status)) { DPRINT1("NtOpenFile() failed with status 0x%.08x\n", Status); - return; + return Status; } // If read_write is specified, then the volume should be exclusively locked - if (read_write) fs_lock(TRUE); + if (read_write) + { + Status = fs_lock(TRUE); + } // Query geometry and partition info, to have bytes per sector, etc @@ -192,6 +195,8 @@ void fs_open(PUNICODE_STRING DriveRoot, int read_write) changes = last = NULL; did_change = 0; + + return Status; } BOOLEAN fs_isdirty(void) @@ -231,6 +236,13 @@ NTSTATUS fs_lock(BOOLEAN LockVolume) if (!NT_SUCCESS(Status)) { DPRINT1("NtFsControlFile() failed with Status 0x%08x\n", Status); +#if 1 + /* FIXME: ReactOS HACK for 1stage due to IopParseDevice() hack */ + if (Status == STATUS_INVALID_DEVICE_REQUEST) + { + Status = STATUS_ACCESS_DENIED; + } +#endif } return Status; diff --git a/sdk/lib/fslib/vfatlib/check/io.h b/sdk/lib/fslib/vfatlib/check/io.h index 1178cd1e5b..23c6fd6a71 100644 --- a/sdk/lib/fslib/vfatlib/check/io.h +++ b/sdk/lib/fslib/vfatlib/check/io.h @@ -34,7 +34,7 @@ //#include <sys/types.h> /* for loff_t */ // #include <fcntl.h> /* for off_t */ -void fs_open(PUNICODE_STRING DriveRoot, int read_write); +NTSTATUS fs_open(PUNICODE_STRING DriveRoot, int read_write); /* Opens the file system PATH. If RW is zero, the file system is opened read-only, otherwise, it is opened read-write. */ diff --git a/sdk/lib/fslib/vfatlib/vfatlib.c b/sdk/lib/fslib/vfatlib/vfatlib.c index 267d3a1275..8db6e8a11a 100644 --- a/sdk/lib/fslib/vfatlib/vfatlib.c +++ b/sdk/lib/fslib/vfatlib/vfatlib.c @@ -383,6 +383,7 @@ VfatChkdsk(IN PUNICODE_STRING DriveRoot, BOOLEAN salvage_files; ULONG free_clusters; DOS_FS fs; + NTSTATUS Status; RtlZeroMemory(&fs, sizeof(fs)); @@ -403,7 +404,20 @@ VfatChkdsk(IN PUNICODE_STRING DriveRoot, salvage_files = TRUE; /* Open filesystem and lock it */ - fs_open(DriveRoot, FsCheckFlags & FSCHECK_READ_WRITE); + Status = fs_open(DriveRoot, FsCheckFlags & FSCHECK_READ_WRITE); + if (Status == STATUS_ACCESS_DENIED) + { + /* We failed to lock, ask the caller whether we should continue */ + if (Callback(VOLUMEINUSE, 0, NULL)) + { + Status = STATUS_SUCCESS; + } + } + if (!NT_SUCCESS(Status)) + { + fs_close(FALSE); + return STATUS_DISK_CORRUPT_ERROR; + } if (CheckOnlyIfDirty && !fs_isdirty()) {

6 years, 9 months

[reactos] 01/01: [SMDLL] Use precomp.h in dllmain.c.

by Amine Khaldi

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=287d7cd80a5308624002a… commit 287d7cd80a5308624002a5d035bfdd7a56fc2c11 Author: Amine Khaldi <amine.khaldi(a)reactos.org> AuthorDate: Sat Dec 9 20:47:27 2017 +0100 [SMDLL] Use precomp.h in dllmain.c. --- dll/win32/smdll/dllmain.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dll/win32/smdll/dllmain.c b/dll/win32/smdll/dllmain.c index 69f2554890..604f8944d4 100644 --- a/dll/win32/smdll/dllmain.c +++ b/dll/win32/smdll/dllmain.c @@ -5,7 +5,7 @@ * PURPOSE: SM Helper Library */ -#include <windef.h> +#include "precomp.h" BOOL WINAPI DllMainCRTStartup(HANDLE hinstDll, DWORD fdwReason, LPVOID fImpLoad) {

6 years, 9 months

← Newer
1
...
25
26
27
28
29
30
31
...
36
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs December 2017