Ros-diffs January 2025

ros-diffs@reactos.org

23 participants
278 discussions

[reactos] 10/11: [NTOS:IO] Improve some comments in IoVolumeDeviceToDosName()

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=f315111bb583b1911d1d9… commit f315111bb583b1911d1d9069c964ca5d4735ac18 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Thu Jan 9 19:34:56 2025 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Tue Jan 21 19:16:02 2025 +0100 [NTOS:IO] Improve some comments in IoVolumeDeviceToDosName() Addendum to commit 5afb7ab003. --- ntoskrnl/io/iomgr/volume.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/ntoskrnl/io/iomgr/volume.c b/ntoskrnl/io/iomgr/volume.c index 3f614e27c98..5d5614b4454 100644 --- a/ntoskrnl/io/iomgr/volume.c +++ b/ntoskrnl/io/iomgr/volume.c @@ -1328,7 +1328,7 @@ IoVolumeDeviceToDosName( return Status; } - /* Now, query the MountMgr for the DOS path */ + /* Retrieve the MountMgr controlling device */ RtlInitUnicodeString(&MountMgrDevice, MOUNTMGR_DEVICE_NAME); Status = IoGetDeviceObjectPointer(&MountMgrDevice, FILE_READ_ATTRIBUTES, &FileObject, &DeviceObject); @@ -1337,6 +1337,7 @@ IoVolumeDeviceToDosName( return Status; } + /* Now, query the MountMgr for the DOS path */ KeInitializeEvent(&Event, NotificationEvent, FALSE); Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH, DeviceObject, @@ -1362,7 +1363,7 @@ IoVolumeDeviceToDosName( goto Quit; } - /* Compute the needed size to store the DOS name. + /* Compute the needed size to store the DOS path. * Even if MOUNTMGR_VOLUME_PATHS allows bigger name lengths * than MAXUSHORT, we can't use them, because we have to return * this in an UNICODE_STRING that stores length in a USHORT. */ @@ -1373,8 +1374,8 @@ IoVolumeDeviceToDosName( goto Quit; } - /* Reallocate the memory, even in case of success, because - * that's the buffer that will be returned to the caller */ + /* Allocate the buffer, even in case of success, + * because it is returned to the caller */ VolumePathPtr = ExAllocatePoolWithTag(PagedPool, Length, TAG_DEV2DOS); if (!VolumePathPtr) {

2 weeks, 1 day

[reactos] 09/11: [MOUNTMGR] Fix the buffer returned by IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH (#6990)

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c306a27941ab74941247a… commit c306a27941ab74941247a13155be5c6980f6cda3 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Sun Jan 19 23:11:04 2025 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Tue Jan 21 19:16:01 2025 +0100 [MOUNTMGR] Fix the buffer returned by IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH (#6990) The buffer returned by MountMgrQueryDosVolumePath() should be a multi-string containing one single string. --- drivers/storage/mountmgr/device.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/drivers/storage/mountmgr/device.c b/drivers/storage/mountmgr/device.c index 22710b7b4d7..7000d4a4218 100644 --- a/drivers/storage/mountmgr/device.c +++ b/drivers/storage/mountmgr/device.c @@ -1004,8 +1004,8 @@ TryWithVolumeName: Output = (PMOUNTMGR_VOLUME_PATHS)Irp->AssociatedIrp.SystemBuffer; /* At least, we will return our length */ - Output->MultiSzLength = DeviceLength; - Irp->IoStatus.Information = FIELD_OFFSET(MOUNTMGR_VOLUME_PATHS, MultiSz) + DeviceLength; + Output->MultiSzLength = DeviceLength + 2 * sizeof(UNICODE_NULL); + Irp->IoStatus.Information = FIELD_OFFSET(MOUNTMGR_VOLUME_PATHS, MultiSz) + Output->MultiSzLength; /* If we have enough room for copying the string */ if (Irp->IoStatus.Information <= Stack->Parameters.DeviceIoControl.OutputBufferLength)

2 weeks, 1 day

[reactos] 08/11: [MOUNTMGR] Fix three more bugs in MountMgrQueryDosVolumePath() (#6990)

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=8bb7cd286bc106dd67a86… commit 8bb7cd286bc106dd67a869e045d589960873bd1b Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Sun Jan 19 23:00:04 2025 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Tue Jan 21 19:16:01 2025 +0100 [MOUNTMGR] Fix three more bugs in MountMgrQueryDosVolumePath() (#6990) - When trying to find a device, don't fail with STATUS_NOT_FOUND if no associated symbolic links are present. Instead, that test was wrong, and should go out of the search loop to do the drive-letter processing. Addendum to commit f9f5a78715. - In addition, when using the associated-device method, fix the list used to retrieve the corresponding device. - In the TryWithVolumeName: block, reset DeviceString to NULL after freeing, so that we can correctly fail with STATUS_NOT_FOUND if no suitable device was found, before initializing the output data. --- drivers/storage/mountmgr/device.c | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/drivers/storage/mountmgr/device.c b/drivers/storage/mountmgr/device.c index fdf6af9435b..22710b7b4d7 100644 --- a/drivers/storage/mountmgr/device.c +++ b/drivers/storage/mountmgr/device.c @@ -887,20 +887,16 @@ MountMgrQueryDosVolumePath(IN PDEVICE_EXTENSION DeviceExtension, } } - /* We didn't find, break */ - if (SymlinksEntry == &(DeviceInformation->SymbolicLinksListHead)) - { - return STATUS_NOT_FOUND; - } + /* If we've found a device via drive letter, do default processing */ + if (SymlinksEntry != &(DeviceInformation->SymbolicLinksListHead)) + break; - /* It doesn't have associated device, go to fallback method */ + /* If it doesn't have an associated device, go to fallback method */ if (IsListEmpty(&DeviceInformation->AssociatedDevicesHead)) - { goto TryWithVolumeName; - } /* Create a string with the information about the device */ - AssociatedDevice = CONTAINING_RECORD(&(DeviceInformation->SymbolicLinksListHead), ASSOCIATED_DEVICE_ENTRY, AssociatedDevicesEntry); + AssociatedDevice = CONTAINING_RECORD(&(DeviceInformation->AssociatedDevicesHead), ASSOCIATED_DEVICE_ENTRY, AssociatedDevicesEntry); OldLength = DeviceLength; OldBuffer = DeviceString; DeviceLength += AssociatedDevice->String.Length; @@ -967,6 +963,7 @@ TryWithVolumeName: if (DeviceString) { FreePool(DeviceString); + DeviceString = NULL; DeviceLength = 0; }

2 weeks, 1 day

[reactos] 07/11: [MOUNTMGR] Simplify a bit the code in MountMgrQueryDosVolumePath(s) (#6990)

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=28c3533d1113f5b7ea849… commit 28c3533d1113f5b7ea849d0f8d8f3c0480639837 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Sun Jan 19 22:54:02 2025 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Tue Jan 21 19:16:00 2025 +0100 [MOUNTMGR] Simplify a bit the code in MountMgrQueryDosVolumePath(s) (#6990) --- drivers/storage/mountmgr/device.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/drivers/storage/mountmgr/device.c b/drivers/storage/mountmgr/device.c index 58a478115e9..fdf6af9435b 100644 --- a/drivers/storage/mountmgr/device.c +++ b/drivers/storage/mountmgr/device.c @@ -856,7 +856,7 @@ MountMgrQueryDosVolumePath(IN PDEVICE_EXTENSION DeviceExtension, } /* Construct string for query */ - SymbolicName.Length = Target->DeviceNameLength; + SymbolicName.Length = SymbolicName.MaximumLength = Target->DeviceNameLength; SymbolicName.Buffer = Target->DeviceName; @@ -1482,8 +1482,8 @@ MountMgrQueryDosVolumePaths(IN PDEVICE_EXTENSION DeviceExtension, } /* Construct string for query */ - SymbolicName.Length = Target->DeviceNameLength; - SymbolicName.MaximumLength = Target->DeviceNameLength + sizeof(UNICODE_NULL); + SymbolicName.Length = + SymbolicName.MaximumLength = Target->DeviceNameLength; SymbolicName.Buffer = Target->DeviceName; /* Find device with our info */

2 weeks, 1 day

[reactos] 06/11: [MOUNTMGR] Fix some other bugs (#6990)

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=e72a9a78b0148254c35f8… commit e72a9a78b0148254c35f80f368516d7368a9799b Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Sun Jan 19 22:32:25 2025 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Tue Jan 21 19:15:59 2025 +0100 [MOUNTMGR] Fix some other bugs (#6990) - Use FIELD_OFFSET to correct structure and member instead of hardcoding sizeof-s of fields until the member of interest. - Fix a bug in MountMgrQueryDosVolumePath() where the FIELD_OFFSET used in the entry structure size validation was incorrect. FIELD_OFFSET(MOUNTMGR_TARGET_NAME, DeviceNameLength) is == 0 since DeviceNameLength is the first member of the MOUNTMGR_TARGET_NAME structure. The intended member was DeviceName. Addendum to commit f9f5a78715. --- drivers/storage/mountmgr/device.c | 29 ++++++++++++++++------------- 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/drivers/storage/mountmgr/device.c b/drivers/storage/mountmgr/device.c index 62d28cf7192..58a478115e9 100644 --- a/drivers/storage/mountmgr/device.c +++ b/drivers/storage/mountmgr/device.c @@ -637,7 +637,8 @@ MountMgrNextDriveLetter(IN PDEVICE_EXTENSION DeviceExtension, } DriveLetterTarget = (PMOUNTMGR_DRIVE_LETTER_TARGET)Irp->AssociatedIrp.SystemBuffer; - if (DriveLetterTarget->DeviceNameLength + sizeof(USHORT) > Stack->Parameters.DeviceIoControl.InputBufferLength) + if (FIELD_OFFSET(MOUNTMGR_DRIVE_LETTER_TARGET, DeviceName) + DriveLetterTarget->DeviceNameLength > + Stack->Parameters.DeviceIoControl.InputBufferLength) { return STATUS_INVALID_PARAMETER; } @@ -842,14 +843,14 @@ MountMgrQueryDosVolumePath(IN PDEVICE_EXTENSION DeviceExtension, } /* Validate the entry structure size */ - if ((FIELD_OFFSET(MOUNTMGR_TARGET_NAME, DeviceNameLength) + Target->DeviceNameLength) > + if (FIELD_OFFSET(MOUNTMGR_TARGET_NAME, DeviceName) + Target->DeviceNameLength > Stack->Parameters.DeviceIoControl.InputBufferLength) { return STATUS_INVALID_PARAMETER; } /* Ensure we can at least return needed size */ - if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG)) + if (Stack->Parameters.DeviceIoControl.OutputBufferLength < FIELD_OFFSET(MOUNTMGR_VOLUME_PATHS, MultiSz)) { return STATUS_INVALID_PARAMETER; } @@ -1007,11 +1008,10 @@ TryWithVolumeName: /* At least, we will return our length */ Output->MultiSzLength = DeviceLength; - /* MOUNTMGR_VOLUME_PATHS is a string + a ULONG */ - Irp->IoStatus.Information = DeviceLength + sizeof(ULONG); + Irp->IoStatus.Information = FIELD_OFFSET(MOUNTMGR_VOLUME_PATHS, MultiSz) + DeviceLength; /* If we have enough room for copying the string */ - if (sizeof(ULONG) + DeviceLength <= Stack->Parameters.DeviceIoControl.OutputBufferLength) + if (Irp->IoStatus.Information <= Stack->Parameters.DeviceIoControl.OutputBufferLength) { /* Copy it */ if (DeviceLength) @@ -1031,7 +1031,7 @@ TryWithVolumeName: { /* Just return the size needed and leave */ FreePool(DeviceString); - Irp->IoStatus.Information = sizeof(ULONG); + Irp->IoStatus.Information = FIELD_OFFSET(MOUNTMGR_VOLUME_PATHS, MultiSz); return STATUS_BUFFER_OVERFLOW; } } @@ -1469,13 +1469,14 @@ MountMgrQueryDosVolumePaths(IN PDEVICE_EXTENSION DeviceExtension, } /* Validate the entry structure size */ - if (Target->DeviceNameLength + FIELD_OFFSET(MOUNTMGR_TARGET_NAME, DeviceName) > Stack->Parameters.DeviceIoControl.InputBufferLength) + if (FIELD_OFFSET(MOUNTMGR_TARGET_NAME, DeviceName) + Target->DeviceNameLength > + Stack->Parameters.DeviceIoControl.InputBufferLength) { return STATUS_INVALID_PARAMETER; } /* Ensure we can at least return needed size */ - if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG)) + if (Stack->Parameters.DeviceIoControl.OutputBufferLength < FIELD_OFFSET(MOUNTMGR_VOLUME_PATHS, MultiSz)) { return STATUS_INVALID_PARAMETER; } @@ -1566,12 +1567,12 @@ MountMgrQueryDosVolumePaths(IN PDEVICE_EXTENSION DeviceExtension, Output->MultiSzLength = Paths->MultiSzLength; /* Compute total length */ - OutputLength = Output->MultiSzLength + sizeof(ULONG); + OutputLength = FIELD_OFFSET(MOUNTMGR_VOLUME_PATHS, MultiSz) + Output->MultiSzLength; /* If it cannot fit, just return the size needed and leave */ if (OutputLength > Stack->Parameters.DeviceIoControl.OutputBufferLength) { - Irp->IoStatus.Information = sizeof(ULONG); + Irp->IoStatus.Information = FIELD_OFFSET(MOUNTMGR_VOLUME_PATHS, MultiSz); FreePool(Paths); return STATUS_BUFFER_OVERFLOW; } @@ -1605,7 +1606,8 @@ MountMgrKeepLinksWhenOffline(IN PDEVICE_EXTENSION DeviceExtension, } Target = (PMOUNTMGR_TARGET_NAME)Irp->AssociatedIrp.SystemBuffer; - if (Target->DeviceNameLength + sizeof(USHORT) > Stack->Parameters.DeviceIoControl.InputBufferLength) + if (FIELD_OFFSET(MOUNTMGR_TARGET_NAME, DeviceName) + Target->DeviceNameLength > + Stack->Parameters.DeviceIoControl.InputBufferLength) { return STATUS_INVALID_PARAMETER; } @@ -1649,7 +1651,8 @@ MountMgrVolumeArrivalNotification(IN PDEVICE_EXTENSION DeviceExtension, } Target = (PMOUNTMGR_TARGET_NAME)Irp->AssociatedIrp.SystemBuffer; - if (Target->DeviceNameLength + sizeof(USHORT) > Stack->Parameters.DeviceIoControl.InputBufferLength) + if (FIELD_OFFSET(MOUNTMGR_TARGET_NAME, DeviceName) + Target->DeviceNameLength > + Stack->Parameters.DeviceIoControl.InputBufferLength) { return STATUS_INVALID_PARAMETER; }

2 weeks, 1 day

[reactos] 05/11: [MOUNTMGR] Simplify MountMgrQueryDosVolumePath() code (#6990)

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=be97a36f25c3fec7ad8ca… commit be97a36f25c3fec7ad8ca6c43aeadfe12d9eab34 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Sun Jan 19 22:23:56 2025 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Tue Jan 21 19:15:59 2025 +0100 [MOUNTMGR] Simplify MountMgrQueryDosVolumePath() code (#6990) - Use a variable of correct type instead of casting every time. - Remove one level of indentation by returning early. --- drivers/storage/mountmgr/device.c | 66 ++++++++++++++++++++------------------- 1 file changed, 34 insertions(+), 32 deletions(-) diff --git a/drivers/storage/mountmgr/device.c b/drivers/storage/mountmgr/device.c index ca8ed5c1395..62d28cf7192 100644 --- a/drivers/storage/mountmgr/device.c +++ b/drivers/storage/mountmgr/device.c @@ -819,6 +819,7 @@ MountMgrQueryDosVolumePath(IN PDEVICE_EXTENSION DeviceExtension, PLIST_ENTRY SymlinksEntry; UNICODE_STRING SymbolicName; PMOUNTMGR_TARGET_NAME Target; + PMOUNTMGR_VOLUME_PATHS Output; PWSTR DeviceString, OldBuffer; USHORT DeviceLength, OldLength; PDEVICE_INFORMATION DeviceInformation; @@ -992,46 +993,47 @@ TryWithVolumeName: } RtlCopyMemory(DeviceString, SymlinkInformation->Name.Buffer, DeviceLength); - /* Ensure we are in the right namespace; [1] can be ? */ + /* Ensure we are in the Win32 namespace; [1] can be '?' */ DeviceString[1] = L'\\'; } } - /* If we found something */ - if (DeviceString) - { - /* At least, we will return our length */ - ((PMOUNTMGR_VOLUME_PATHS)Irp->AssociatedIrp.SystemBuffer)->MultiSzLength = DeviceLength; - /* MOUNTMGR_VOLUME_PATHS is a string + a ULONG */ - Irp->IoStatus.Information = DeviceLength + sizeof(ULONG); + /* If we didn't find something, fail */ + if (!DeviceString) + return STATUS_NOT_FOUND; - /* If we have enough room for copying the string */ - if (sizeof(ULONG) + DeviceLength <= Stack->Parameters.DeviceIoControl.OutputBufferLength) - { - /* Copy it */ - if (DeviceLength) - { - RtlCopyMemory(((PMOUNTMGR_VOLUME_PATHS)Irp->AssociatedIrp.SystemBuffer)->MultiSz, DeviceString, DeviceLength); - } + /* Get the output buffer */ + Output = (PMOUNTMGR_VOLUME_PATHS)Irp->AssociatedIrp.SystemBuffer; - /* And double zero at its end - this is needed in case of multiple paths which are separated by a single 0 */ - FreePool(DeviceString); - ((PMOUNTMGR_VOLUME_PATHS)Irp->AssociatedIrp.SystemBuffer)->MultiSz[DeviceLength / sizeof(WCHAR)] = 0; - ((PMOUNTMGR_VOLUME_PATHS)Irp->AssociatedIrp.SystemBuffer)->MultiSz[DeviceLength / sizeof(WCHAR) + 1] = 0; + /* At least, we will return our length */ + Output->MultiSzLength = DeviceLength; + /* MOUNTMGR_VOLUME_PATHS is a string + a ULONG */ + Irp->IoStatus.Information = DeviceLength + sizeof(ULONG); - return STATUS_SUCCESS; - } - else + /* If we have enough room for copying the string */ + if (sizeof(ULONG) + DeviceLength <= Stack->Parameters.DeviceIoControl.OutputBufferLength) + { + /* Copy it */ + if (DeviceLength) { - /* Just return appropriate size and leave */ - FreePool(DeviceString); - Irp->IoStatus.Information = sizeof(ULONG); - return STATUS_BUFFER_OVERFLOW; + RtlCopyMemory(Output->MultiSz, DeviceString, DeviceLength); } - } - /* Fail */ - return STATUS_NOT_FOUND; + /* And double-NUL at its end - this is needed in case of + * multiple paths which are separated by a single NUL */ + FreePool(DeviceString); + Output->MultiSz[DeviceLength / sizeof(WCHAR)] = UNICODE_NULL; + Output->MultiSz[DeviceLength / sizeof(WCHAR) + 1] = UNICODE_NULL; + + return STATUS_SUCCESS; + } + else + { + /* Just return the size needed and leave */ + FreePool(DeviceString); + Irp->IoStatus.Information = sizeof(ULONG); + return STATUS_BUFFER_OVERFLOW; + } } /* @@ -1557,7 +1559,7 @@ MountMgrQueryDosVolumePaths(IN PDEVICE_EXTENSION DeviceExtension, MountMgrNotifyNameChange(DeviceExtension, &SymbolicName, FALSE); } - /* Get output buffer */ + /* Get the output buffer */ Output = (PMOUNTMGR_VOLUME_PATHS)Irp->AssociatedIrp.SystemBuffer; /* Set required size */ @@ -1566,7 +1568,7 @@ MountMgrQueryDosVolumePaths(IN PDEVICE_EXTENSION DeviceExtension, /* Compute total length */ OutputLength = Output->MultiSzLength + sizeof(ULONG); - /* If it cannot fit, just return need size and quit */ + /* If it cannot fit, just return the size needed and leave */ if (OutputLength > Stack->Parameters.DeviceIoControl.OutputBufferLength) { Irp->IoStatus.Information = sizeof(ULONG);

2 weeks, 1 day

[reactos] 04/11: [KMTESTS] Improve IoVolumeDeviceToDosName() tests (#6990)

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=bae799382aa84dc54d01d… commit bae799382aa84dc54d01ddbc7259609194f922b5 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Sat Jan 11 22:31:47 2025 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Tue Jan 21 19:15:58 2025 +0100 [KMTESTS] Improve IoVolumeDeviceToDosName() tests (#6990) - Limit the HarddiskVolume loop to 32 trials (instead of an unknown number of them). Ideally the list of volumes has to be queried from the volume manager, instead of hardcoding them (TODO). - Verify that the buffer returned by IoVolumeDeviceToDosName() is indeed a unicode multi-string (ends with two NULs), and, in the case it specifies a volume GUID, that it's a valid one. --- modules/rostests/kmtests/ntos_io/IoVolume.c | 29 +++++++++++++++++++++++------ 1 file changed, 23 insertions(+), 6 deletions(-) diff --git a/modules/rostests/kmtests/ntos_io/IoVolume.c b/modules/rostests/kmtests/ntos_io/IoVolume.c index 51d5eccfb3f..a0824e5ef82 100644 --- a/modules/rostests/kmtests/ntos_io/IoVolume.c +++ b/modules/rostests/kmtests/ntos_io/IoVolume.c @@ -6,7 +6,7 @@ */ #include <kmt_test.h> - +#include <mountmgr.h> static void @@ -24,17 +24,16 @@ TestIoVolumeDeviceToDosName(void) RtlInitEmptyUnicodeString(&VolumeDeviceName, VolumeDeviceNameBuffer, sizeof(VolumeDeviceNameBuffer)); - VolumeNumber = 0; - while (1) + // TODO: Query the partition/volume manager for the list of volumes. + for (VolumeNumber = 0; VolumeNumber < 32; ++VolumeNumber) { - VolumeNumber++; Status = RtlStringCbPrintfW(VolumeDeviceName.Buffer, VolumeDeviceName.MaximumLength, L"\\Device\\HarddiskVolume%lu", VolumeNumber); if (!NT_SUCCESS(Status)) { - trace("RtlStringCbPrintfW(0x%lx) failed with %lx\n", + trace("RtlStringCbPrintfW(%lu) failed with 0x%lx\n", VolumeNumber, Status); break; } @@ -46,7 +45,7 @@ TestIoVolumeDeviceToDosName(void) &DeviceObject); if (!NT_SUCCESS(Status)) { - trace("IoGetDeviceObjectPointer(%wZ) failed with %lx\n", + trace("IoGetDeviceObjectPointer(%wZ) failed with 0x%lx\n", &VolumeDeviceName, Status); continue; } @@ -56,6 +55,22 @@ TestIoVolumeDeviceToDosName(void) if (!skip(NT_SUCCESS(Status), "No DOS name\n")) { trace("DOS name for %wZ is %wZ\n", &VolumeDeviceName, &DosName); + + /* The DosName should contain one NUL-terminated string (always there?), + * plus one final NUL-terminator */ + ok(DosName.MaximumLength == DosName.Length + sizeof(UNICODE_NULL), + "Unexpected DOS name maximum length %hu, expected %hu\n", + DosName.MaximumLength, DosName.Length + sizeof(UNICODE_NULL)); + ok(DosName.Length >= sizeof(UNICODE_NULL), + "DOS name too short (length: %lu)\n", + DosName.Length / sizeof(WCHAR)); + ok(DosName.Buffer[DosName.Length / sizeof(WCHAR)] == UNICODE_NULL, + "Missing NUL-terminator (1)\n"); + ok(DosName.Buffer[DosName.MaximumLength / sizeof(WCHAR) - 1] == UNICODE_NULL, + "Missing NUL-terminator (2)\n"); + + /* The DOS name is either a drive letter, or a + * volume GUID name (if the volume is not mounted) */ if (DosName.Length == 2 * sizeof(WCHAR)) { ok(DosName.Buffer[0] >= L'A' && @@ -67,6 +82,8 @@ TestIoVolumeDeviceToDosName(void) { ok(RtlPrefixUnicodeString(&DosVolumePrefix, &DosName, FALSE), "Unexpected volume path: %wZ\n", &DosName); + ok(MOUNTMGR_IS_DOS_VOLUME_NAME(&DosName), + "Invalid DOS volume path returned: %wZ\n", &DosName); } RtlFreeUnicodeString(&DosName); }

2 weeks, 1 day

[reactos] 03/11: [MOUNTMGR_APITEST] Add tests for mountmgr IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH(S) (#6990)

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=cc1deb29024ae58e52832… commit cc1deb29024ae58e52832f8bb07ac23fdbafe281 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Mon Jan 6 21:54:20 2025 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Tue Jan 21 19:15:57 2025 +0100 [MOUNTMGR_APITEST] Add tests for mountmgr IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH(S) (#6990) These tests verify the output of IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH, IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATHS and IOCTL_MOUNTMGR_QUERY_POINTS, as well as their consistency. References: https://www.osronline.com/article.cfm%5Eid=107.htm https://community.osr.com/t/obtaining-volume-name-with-deviceobject/15121/3 --- modules/rostests/apitests/mountmgr/CMakeLists.txt | 1 + .../apitests/mountmgr/QueryDosVolumePaths.c | 635 +++++++++++++++++++++ modules/rostests/apitests/mountmgr/precomp.h | 5 + modules/rostests/apitests/mountmgr/testlist.c | 2 + modules/rostests/apitests/mountmgr/utils.c | 53 ++ 5 files changed, 696 insertions(+) diff --git a/modules/rostests/apitests/mountmgr/CMakeLists.txt b/modules/rostests/apitests/mountmgr/CMakeLists.txt index dbba2775f56..c53e4d79aff 100644 --- a/modules/rostests/apitests/mountmgr/CMakeLists.txt +++ b/modules/rostests/apitests/mountmgr/CMakeLists.txt @@ -1,5 +1,6 @@ list(APPEND SOURCE + QueryDosVolumePaths.c QueryPoints.c utils.c) diff --git a/modules/rostests/apitests/mountmgr/QueryDosVolumePaths.c b/modules/rostests/apitests/mountmgr/QueryDosVolumePaths.c new file mode 100644 index 00000000000..138e45bd56e --- /dev/null +++ b/modules/rostests/apitests/mountmgr/QueryDosVolumePaths.c @@ -0,0 +1,635 @@ +/* + * PROJECT: ReactOS API Tests + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Test for IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH(S) + * COPYRIGHT: Copyright 2025 Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> + */ + +#include "precomp.h" + + +/** + * @brief + * Invokes either IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH or + * IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATHS for testing, given + * the volume device name, and returns an allocated volume + * paths buffer. This buffer must be freed by the caller via + * RtlFreeHeap(RtlGetProcessHeap(), ...) . + * + * These IOCTLs return both the drive letter (if any) and the + * volume GUID symlink path, as well as any other file-system + * mount reparse points linking to the volume. + **/ +static VOID +Call_QueryDosVolume_Path_Paths( + _In_ HANDLE MountMgrHandle, + _In_ PCWSTR NtVolumeName, + _In_ ULONG IoctlPathOrPaths, + _Out_ PMOUNTMGR_VOLUME_PATHS* pVolumePathPtr) +{ + NTSTATUS Status; + ULONG Length; + IO_STATUS_BLOCK IoStatusBlock; + UNICODE_STRING VolumeName; + MOUNTMGR_VOLUME_PATHS VolumePath; + PMOUNTMGR_VOLUME_PATHS VolumePathPtr; + ULONG DeviceNameLength; + /* + * This variable is used to query the device name. + * It's based on MOUNTMGR_TARGET_NAME (mountmgr.h). + * Doing it this way prevents memory allocation. + * The device name won't be longer. + */ + struct + { + USHORT NameLength; + WCHAR DeviceName[256]; + } DeviceName; + + + *pVolumePathPtr = NULL; + + /* First, build the corresponding device name */ + RtlInitUnicodeString(&VolumeName, NtVolumeName); + DeviceName.NameLength = VolumeName.Length; + RtlCopyMemory(&DeviceName.DeviceName, VolumeName.Buffer, VolumeName.Length); + DeviceNameLength = FIELD_OFFSET(MOUNTMGR_TARGET_NAME, DeviceName) + DeviceName.NameLength; + + /* Now, query the MountMgr for the DOS path(s) */ + Status = NtDeviceIoControlFile(MountMgrHandle, + NULL, NULL, NULL, + &IoStatusBlock, + IoctlPathOrPaths, + &DeviceName, DeviceNameLength, + &VolumePath, sizeof(VolumePath)); + + /* Check for unsupported device */ + if (Status == STATUS_NO_MEDIA_IN_DEVICE || Status == STATUS_INVALID_DEVICE_REQUEST) + { + skip("Device '%S': Doesn't support MountMgr queries, Status 0x%08lx\n", + NtVolumeName, Status); + return; + } + + /* The only tolerated failure here is buffer too small, which is expected */ + ok(NT_SUCCESS(Status) || (Status == STATUS_BUFFER_OVERFLOW), + "Device '%S': IOCTL 0x%lx failed unexpectedly, Status 0x%08lx\n", + NtVolumeName, IoctlPathOrPaths, Status); + if (!NT_SUCCESS(Status) && (Status != STATUS_BUFFER_OVERFLOW)) + { + skip("Device '%S': Wrong Status\n", NtVolumeName); + return; + } + + /* Compute the needed size to store the DOS path(s). + * Even if MOUNTMGR_VOLUME_PATHS allows bigger name lengths + * than MAXUSHORT, we can't use them, because we have to return + * this in an UNICODE_STRING that stores length in a USHORT. */ + Length = sizeof(VolumePath) + VolumePath.MultiSzLength; + ok(Length <= MAXUSHORT, + "Device '%S': DOS volume path too large: %lu\n", + NtVolumeName, Length); + if (Length > MAXUSHORT) + { + skip("Device '%S': Wrong Length\n", NtVolumeName); + return; + } + + /* Allocate the buffer and fill it with test pattern */ + VolumePathPtr = RtlAllocateHeap(RtlGetProcessHeap(), 0, Length); + if (!VolumePathPtr) + { + skip("Device '%S': Failed to allocate buffer with size %lu)\n", + NtVolumeName, Length); + return; + } + RtlFillMemory(VolumePathPtr, Length, 0xCC); + + /* Re-query the DOS path(s) with the proper size */ + Status = NtDeviceIoControlFile(MountMgrHandle, + NULL, NULL, NULL, + &IoStatusBlock, + IoctlPathOrPaths, + &DeviceName, DeviceNameLength, + VolumePathPtr, Length); + ok(NT_SUCCESS(Status), + "Device '%S': IOCTL 0x%lx failed unexpectedly, Status 0x%08lx\n", + NtVolumeName, IoctlPathOrPaths, Status); + + if (winetest_debug > 1) + { + trace("Buffer:\n"); + DumpBuffer(VolumePathPtr, Length); + printf("\n"); + } + + /* Return the buffer */ + *pVolumePathPtr = VolumePathPtr; +} + +/** + * @brief + * Invokes IOCTL_MOUNTMGR_QUERY_POINTS for testing, given + * the volume device name, and returns an allocated mount + * points buffer. This buffer must be freed by the caller + * via RtlFreeHeap(RtlGetProcessHeap(), ...) . + * + * This IOCTL only returns both the drive letter (if any) + * and the volume GUID symlink path, but does NOT return + * file-system mount reparse points. + **/ +static VOID +Call_QueryPoints( + _In_ HANDLE MountMgrHandle, + _In_ PCWSTR NtVolumeName, + _Out_ PMOUNTMGR_MOUNT_POINTS* pMountPointsPtr) +{ + NTSTATUS Status; + ULONG Length; + IO_STATUS_BLOCK IoStatusBlock; + UNICODE_STRING VolumeName; + MOUNTMGR_MOUNT_POINTS MountPoints; + PMOUNTMGR_MOUNT_POINTS MountPointsPtr; + /* + * This variable is used to query the device name. + * It's based on MOUNTMGR_MOUNT_POINT (mountmgr.h). + * Doing it this way prevents memory allocation. + * The device name won't be longer. + */ + struct + { + MOUNTMGR_MOUNT_POINT; + WCHAR DeviceName[256]; + } DeviceName; + + + *pMountPointsPtr = NULL; + + /* First, build the corresponding device name */ + RtlInitUnicodeString(&VolumeName, NtVolumeName); + DeviceName.SymbolicLinkNameOffset = DeviceName.UniqueIdOffset = 0; + DeviceName.SymbolicLinkNameLength = DeviceName.UniqueIdLength = 0; + DeviceName.DeviceNameOffset = ((ULONG_PTR)&DeviceName.DeviceName - (ULONG_PTR)&DeviceName); + DeviceName.DeviceNameLength = VolumeName.Length; + RtlCopyMemory(&DeviceName.DeviceName, VolumeName.Buffer, VolumeName.Length); + + /* Now, query the MountMgr for the mount points */ + Status = NtDeviceIoControlFile(MountMgrHandle, + NULL, NULL, NULL, + &IoStatusBlock, + IOCTL_MOUNTMGR_QUERY_POINTS, + &DeviceName, sizeof(DeviceName), + &MountPoints, sizeof(MountPoints)); + + /* Check for unsupported device */ + if (Status == STATUS_NO_MEDIA_IN_DEVICE || Status == STATUS_INVALID_DEVICE_REQUEST) + { + skip("Device '%S': Doesn't support MountMgr queries, Status 0x%08lx\n", + NtVolumeName, Status); + return; + } + + /* The only tolerated failure here is buffer too small, which is expected */ + ok(NT_SUCCESS(Status) || (Status == STATUS_BUFFER_OVERFLOW), + "Device '%S': IOCTL 0x%lx failed unexpectedly, Status 0x%08lx\n", + NtVolumeName, IOCTL_MOUNTMGR_QUERY_POINTS, Status); + if (!NT_SUCCESS(Status) && (Status != STATUS_BUFFER_OVERFLOW)) + { + skip("Device '%S': Wrong Status\n", NtVolumeName); + return; + } + + /* Compute the needed size to retrieve the mount points */ + Length = MountPoints.Size; + + /* Allocate the buffer and fill it with test pattern */ + MountPointsPtr = RtlAllocateHeap(RtlGetProcessHeap(), 0, Length); + if (!MountPointsPtr) + { + skip("Device '%S': Failed to allocate buffer with size %lu)\n", + NtVolumeName, Length); + return; + } + RtlFillMemory(MountPointsPtr, Length, 0xCC); + + /* Re-query the mount points with the proper size */ + Status = NtDeviceIoControlFile(MountMgrHandle, + NULL, NULL, NULL, + &IoStatusBlock, + IOCTL_MOUNTMGR_QUERY_POINTS, + &DeviceName, sizeof(DeviceName), + MountPointsPtr, Length); + ok(NT_SUCCESS(Status), + "Device '%S': IOCTL 0x%lx failed unexpectedly, Status 0x%08lx\n", + NtVolumeName, IOCTL_MOUNTMGR_QUERY_POINTS, Status); + + if (winetest_debug > 1) + { + trace("IOCTL_MOUNTMGR_QUERY_POINTS returned:\n" + " Size: %lu\n" + " NumberOfMountPoints: %lu\n", + MountPointsPtr->Size, + MountPointsPtr->NumberOfMountPoints); + + trace("Buffer:\n"); + DumpBuffer(MountPointsPtr, Length); + printf("\n"); + } + + /* Return the buffer */ + *pMountPointsPtr = MountPointsPtr; +} + + +#define IS_DRIVE_LETTER_PFX(s) \ + ((s)->Length >= 2*sizeof(WCHAR) && (s)->Buffer[0] >= 'A' && \ + (s)->Buffer[0] <= 'Z' && (s)->Buffer[1] == ':') + +/* Differs from MOUNTMGR_IS_DRIVE_LETTER(): no '\DosDevices\' accounted for */ +#define IS_DRIVE_LETTER(s) \ + (IS_DRIVE_LETTER_PFX(s) && (s)->Length == 2*sizeof(WCHAR)) + + +/** + * @brief Tests the output of IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH. + **/ +static VOID +Test_QueryDosVolumePath( + _In_ PCWSTR NtVolumeName, + _In_ PMOUNTMGR_VOLUME_PATHS VolumePath) +{ + UNICODE_STRING DosPath; + + UNREFERENCED_PARAMETER(NtVolumeName); + + /* The VolumePath should contain one NUL-terminated string (always there?), + * plus one final NUL-terminator */ + ok(VolumePath->MultiSzLength >= 2 * sizeof(UNICODE_NULL), + "DOS volume path string too short (length: %lu)\n", + VolumePath->MultiSzLength / sizeof(WCHAR)); + ok(VolumePath->MultiSz[VolumePath->MultiSzLength / sizeof(WCHAR) - 2] == UNICODE_NULL, + "Missing NUL-terminator (2)\n"); + ok(VolumePath->MultiSz[VolumePath->MultiSzLength / sizeof(WCHAR) - 1] == UNICODE_NULL, + "Missing NUL-terminator (1)\n"); + + /* Build the result string */ + // RtlInitUnicodeString(&DosPath, VolumePath->MultiSz); + DosPath.Length = (USHORT)VolumePath->MultiSzLength - 2 * sizeof(UNICODE_NULL); + DosPath.MaximumLength = DosPath.Length + sizeof(UNICODE_NULL); + DosPath.Buffer = VolumePath->MultiSz; + + /* The returned DOS path is either a drive letter (*WITHOUT* any + * '\DosDevices\' prefix present) or a Win32 file-system reparse point + * path, or a volume GUID name in Win32 format, i.e. prefixed by '\\?\' */ + ok(IS_DRIVE_LETTER_PFX(&DosPath) || MOUNTMGR_IS_DOS_VOLUME_NAME(&DosPath), + "Invalid DOS volume path returned '%s'\n", wine_dbgstr_us(&DosPath)); +} + +/** + * @brief Tests the output of IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATHS. + **/ +static VOID +Test_QueryDosVolumePaths( + _In_ PCWSTR NtVolumeName, + _In_ PMOUNTMGR_VOLUME_PATHS VolumePaths, + _In_opt_ PMOUNTMGR_VOLUME_PATHS VolumePath) +{ + UNICODE_STRING DosPath; + PCWSTR pMountPoint; + + /* The VolumePaths should contain zero or more NUL-terminated strings, + * plus one final NUL-terminator */ + + ok(VolumePaths->MultiSzLength >= sizeof(UNICODE_NULL), + "DOS volume path string too short (length: %lu)\n", + VolumePaths->MultiSzLength / sizeof(WCHAR)); + + /* Check for correct double-NUL-termination, if there is at least one string */ + if (VolumePaths->MultiSzLength >= 2 * sizeof(UNICODE_NULL), + VolumePaths->MultiSz[0] != UNICODE_NULL) + { + ok(VolumePaths->MultiSz[VolumePaths->MultiSzLength / sizeof(WCHAR) - 2] == UNICODE_NULL, + "Missing NUL-terminator (2)\n"); + } + /* Check for the final NUL-terminator */ + ok(VolumePaths->MultiSz[VolumePaths->MultiSzLength / sizeof(WCHAR) - 1] == UNICODE_NULL, + "Missing NUL-terminator (1)\n"); + + if (winetest_debug > 1) + { + trace("\n%S =>\n", NtVolumeName); + for (pMountPoint = VolumePaths->MultiSz; *pMountPoint; + pMountPoint += wcslen(pMountPoint) + 1) + { + printf(" '%S'\n", pMountPoint); + } + printf("\n"); + } + + for (pMountPoint = VolumePaths->MultiSz; *pMountPoint; + pMountPoint += wcslen(pMountPoint) + 1) + { + /* The returned DOS path is either a drive letter (*WITHOUT* any + * '\DosDevices\' prefix present) or a Win32 file-system reparse point + * path, or a volume GUID name in Win32 format, i.e. prefixed by '\\?\' */ + RtlInitUnicodeString(&DosPath, pMountPoint); + ok(IS_DRIVE_LETTER_PFX(&DosPath) || MOUNTMGR_IS_DOS_VOLUME_NAME(&DosPath), + "Invalid DOS volume path returned '%s'\n", wine_dbgstr_us(&DosPath)); + } + + /* + * If provided, verify that the single VolumePath is found at the + * first position in the volume paths list, *IF* this is a DOS path; + * otherwise if it's a Volume{GUID} path, this means there is no + * DOS path associated, and none is listed in the volume paths list. + */ + if (VolumePath) + { + RtlInitUnicodeString(&DosPath, VolumePath->MultiSz); + if (IS_DRIVE_LETTER_PFX(&DosPath)) + { + /* + * The single path is a DOS path (single drive letter or Win32 + * file-system reparse point path). It has to be listed first + * in the volume paths list. + */ + UNICODE_STRING FirstPath; + BOOLEAN AreEqual; + + ok(VolumePaths->MultiSzLength >= 2 * sizeof(UNICODE_NULL), + "DOS VolumePaths list isn't long enough\n"); + ok(*VolumePaths->MultiSz != UNICODE_NULL, + "Empty DOS VolumePaths list\n"); + + RtlInitUnicodeString(&FirstPath, VolumePaths->MultiSz); + AreEqual = RtlEqualUnicodeString(&DosPath, &FirstPath, FALSE); + ok(AreEqual, "DOS paths '%s' and '%s' are not the same!\n", + wine_dbgstr_us(&DosPath), wine_dbgstr_us(&FirstPath)); + } + else if (MOUNTMGR_IS_DOS_VOLUME_NAME(&DosPath)) + { + /* + * The single "DOS" path is actually a volume name. This means + * that it wasn't really mounted, and the volume paths list must + * be empty. It contains only the last NUL-terminator. + */ + ok(VolumePaths->MultiSzLength == sizeof(UNICODE_NULL), + "DOS VolumePaths list isn't 1 WCHAR long\n"); + ok(*VolumePaths->MultiSz == UNICODE_NULL, + "Non-empty DOS VolumePaths list\n"); + } + else + { + /* The volume path is invalid (shouldn't happen) */ + ok(FALSE, "Invalid DOS volume path returned '%s'\n", wine_dbgstr_us(&DosPath)); + } + } +} + +static BOOLEAN +doesPathExistInMountPoints( + _In_ PMOUNTMGR_MOUNT_POINTS MountPoints, + _In_ PUNICODE_STRING DosPath) +{ + UNICODE_STRING DosDevicesPrefix = RTL_CONSTANT_STRING(L"\\DosDevices\\"); + ULONG i; + BOOLEAN IsDosVolName; + BOOLEAN Found = FALSE; + + IsDosVolName = MOUNTMGR_IS_DOS_VOLUME_NAME(DosPath); + /* Temporarily patch \\?\ to \??\ in DosPath for comparison */ + if (IsDosVolName) + DosPath->Buffer[1] = L'?'; + + for (i = 0; i < MountPoints->NumberOfMountPoints; ++i) + { + UNICODE_STRING SymLink; + + SymLink.Length = SymLink.MaximumLength = MountPoints->MountPoints[i].SymbolicLinkNameLength; + SymLink.Buffer = (PWCHAR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[i].SymbolicLinkNameOffset); + + if (IS_DRIVE_LETTER(DosPath)) + { + if (RtlPrefixUnicodeString(&DosDevicesPrefix, &SymLink, FALSE)) + { + /* Advance past the prefix */ + SymLink.Length -= DosDevicesPrefix.Length; + SymLink.MaximumLength -= DosDevicesPrefix.Length; + SymLink.Buffer += DosDevicesPrefix.Length / sizeof(WCHAR); + + Found = RtlEqualUnicodeString(DosPath, &SymLink, FALSE); + } + } + else if (/*MOUNTMGR_IS_DOS_VOLUME_NAME(DosPath) ||*/ // See above + MOUNTMGR_IS_NT_VOLUME_NAME(DosPath)) + { + Found = RtlEqualUnicodeString(DosPath, &SymLink, FALSE); + } + else + { + /* Just test for simple string comparison, the path should not be found */ + Found = RtlEqualUnicodeString(DosPath, &SymLink, FALSE); + } + + /* Stop searching if we've found something */ + if (Found) + break; + } + + /* Revert \??\ back to \\?\ */ + if (IsDosVolName) + DosPath->Buffer[1] = L'\\'; + + return Found; +} + +/** + * @brief Tests the output of IOCTL_MOUNTMGR_QUERY_POINTS. + **/ +static VOID +Test_QueryPoints( + _In_ PCWSTR NtVolumeName, + _In_ PMOUNTMGR_MOUNT_POINTS MountPoints, + _In_opt_ PMOUNTMGR_VOLUME_PATHS VolumePath, + _In_opt_ PMOUNTMGR_VOLUME_PATHS VolumePaths) +{ + UNICODE_STRING DosPath; + PCWSTR pMountPoint; + BOOLEAN ExpectedFound, Found; + + if (winetest_debug > 1) + { + ULONG i; + trace("\n%S =>\n", NtVolumeName); + for (i = 0; i < MountPoints->NumberOfMountPoints; ++i) + { + UNICODE_STRING DevName, SymLink; + + DevName.Length = DevName.MaximumLength = MountPoints->MountPoints[i].DeviceNameLength; + DevName.Buffer = (PWCHAR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[i].DeviceNameOffset); + + SymLink.Length = SymLink.MaximumLength = MountPoints->MountPoints[i].SymbolicLinkNameLength; + SymLink.Buffer = (PWCHAR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[i].SymbolicLinkNameOffset); + + printf(" '%s' -- '%s'\n", wine_dbgstr_us(&DevName), wine_dbgstr_us(&SymLink)); + } + printf("\n"); + } + + /* + * The Win32 file-system reparse point paths are NOT listed amongst + * the mount points. Only the drive letter and the volume GUID name + * are, but in an NT format (using '\DosDevices\' or '\??\' prefixes). + */ + + if (VolumePath) + { + /* VolumePath can either be a drive letter (usual case), a Win32 + * reparse point path (if the volume is mounted only with these), + * or a volume GUID name (if the volume is NOT mounted). */ + RtlInitUnicodeString(&DosPath, VolumePath->MultiSz); + ExpectedFound = (IS_DRIVE_LETTER(&DosPath) || MOUNTMGR_IS_DOS_VOLUME_NAME(&DosPath)); + Found = doesPathExistInMountPoints(MountPoints, &DosPath); + ok(Found == ExpectedFound, + "DOS path '%s' %sfound in the mount points list, expected %sto be found\n", + wine_dbgstr_us(&DosPath), Found ? "" : "NOT ", ExpectedFound ? "" : "NOT "); + } + + if (VolumePaths) + { + /* VolumePaths only contains a drive letter (usual case) or a Win32 + * reparse point path (if the volume is mounted only with these). + * If the volume is NOT mounted, VolumePaths does not list the + * volume GUID name, contrary to VolumePath. */ + for (pMountPoint = VolumePaths->MultiSz; *pMountPoint; + pMountPoint += wcslen(pMountPoint) + 1) + { + /* Only the drive letter (but NOT the volume GUID name!) can be found in the list */ + RtlInitUnicodeString(&DosPath, pMountPoint); + ExpectedFound = IS_DRIVE_LETTER(&DosPath); + Found = doesPathExistInMountPoints(MountPoints, &DosPath); + ok(Found == ExpectedFound, + "DOS path '%s' %sfound in the mount points list, expected %sto be found\n", + wine_dbgstr_us(&DosPath), Found ? "" : "NOT ", ExpectedFound ? "" : "NOT "); + } + } +} + +/** + * @brief + * Tests the consistency of IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH, + * IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATHS and IOCTL_MOUNTMGR_QUERY_POINTS. + **/ +static VOID +Test_QueryDosVolumePathAndPaths( + _In_ HANDLE MountMgrHandle, + _In_ PCWSTR NtVolumeName) +{ + PMOUNTMGR_VOLUME_PATHS VolumePath = NULL; + PMOUNTMGR_VOLUME_PATHS VolumePaths = NULL; + PMOUNTMGR_MOUNT_POINTS MountPoints = NULL; + + if (winetest_debug > 1) + trace("%S\n", NtVolumeName); + + Call_QueryDosVolume_Path_Paths(MountMgrHandle, + NtVolumeName, + IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH, + &VolumePath); + if (VolumePath) + Test_QueryDosVolumePath(NtVolumeName, VolumePath); + else + skip("Device '%S': IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH failed\n", NtVolumeName); + + Call_QueryDosVolume_Path_Paths(MountMgrHandle, + NtVolumeName, + IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATHS, + &VolumePaths); + if (VolumePaths) + Test_QueryDosVolumePaths(NtVolumeName, VolumePaths, VolumePath); + else + skip("Device '%S': IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATHS failed\n", NtVolumeName); + + Call_QueryPoints(MountMgrHandle, NtVolumeName, &MountPoints); + if (MountPoints) + Test_QueryPoints(NtVolumeName, MountPoints, VolumePath, VolumePaths); + else + skip("Device '%S': IOCTL_MOUNTMGR_QUERY_POINTS failed\n", NtVolumeName); + + if (MountPoints) + RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints); + if (VolumePaths) + RtlFreeHeap(RtlGetProcessHeap(), 0, VolumePaths); + if (VolumePath) + RtlFreeHeap(RtlGetProcessHeap(), 0, VolumePath); +} + + +START_TEST(QueryDosVolumePaths) +{ + HANDLE MountMgrHandle; + HANDLE hFindVolume; + WCHAR szVolumeName[MAX_PATH]; + + MountMgrHandle = GetMountMgrHandle(); + if (!MountMgrHandle) + { + win_skip("MountMgr unavailable: %lu\n", GetLastError()); + return; + } + + hFindVolume = FindFirstVolumeW(szVolumeName, _countof(szVolumeName)); + if (hFindVolume == INVALID_HANDLE_VALUE) + goto otherTests; + do + { + UNICODE_STRING VolumeName; + USHORT Length; + + /* + * The Win32 FindFirst/NextVolumeW() functions convert the '\??\' + * prefix in '\??\Volume{...}' to '\\?\' and append a trailing + * backslash. Test this behaviour. + * + * NOTE: these functions actively filter out anything that is NOT + * '\??\Volume{...}' returned from IOCTL_MOUNTMGR_QUERY_POINTS. + * Thus, it also excludes mount-points specified as drive letters, + * like '\DosDevices\C:' . + */ + + RtlInitUnicodeString(&VolumeName, szVolumeName); + Length = VolumeName.Length / sizeof(WCHAR); + ok(Length >= 1 && VolumeName.Buffer[Length - 1] == L'\\', + "No trailing backslash found\n"); + + /* Remove the trailing backslash */ + if (Length >= 1) + { + VolumeName.Length -= sizeof(WCHAR); + if (szVolumeName[Length - 1] == L'\\') + szVolumeName[Length - 1] = UNICODE_NULL; + } + + ok(MOUNTMGR_IS_DOS_VOLUME_NAME(&VolumeName), + "Invalid DOS volume path returned '%s'\n", wine_dbgstr_us(&VolumeName)); + + /* Patch '\\?\' back to '\??\' to convert to an NT path */ + if (szVolumeName[0] == L'\\' && szVolumeName[1] == L'\\' && + szVolumeName[2] == L'?' && szVolumeName[3] == L'\\') + { + szVolumeName[1] = L'?'; + } + + Test_QueryDosVolumePathAndPaths(MountMgrHandle, szVolumeName); + } while (FindNextVolumeW(hFindVolume, szVolumeName, _countof(szVolumeName))); + FindVolumeClose(hFindVolume); + +otherTests: + /* Test the drive containing SystemRoot */ + wcscpy(szVolumeName, L"\\DosDevices\\?:"); + szVolumeName[sizeof("\\DosDevices\\")-1] = SharedUserData->NtSystemRoot[0]; + Test_QueryDosVolumePathAndPaths(MountMgrHandle, szVolumeName); + + /* We are done */ + CloseHandle(MountMgrHandle); +} diff --git a/modules/rostests/apitests/mountmgr/precomp.h b/modules/rostests/apitests/mountmgr/precomp.h index 462f62e1a38..8031f379b24 100644 --- a/modules/rostests/apitests/mountmgr/precomp.h +++ b/modules/rostests/apitests/mountmgr/precomp.h @@ -25,4 +25,9 @@ LPCSTR wine_dbgstr_us(const UNICODE_STRING *us); HANDLE GetMountMgrHandle(VOID); +VOID +DumpBuffer( + _In_ PVOID Buffer, + _In_ ULONG Length); + /* EOF */ diff --git a/modules/rostests/apitests/mountmgr/testlist.c b/modules/rostests/apitests/mountmgr/testlist.c index ab7c0921a26..9c96445bbcd 100644 --- a/modules/rostests/apitests/mountmgr/testlist.c +++ b/modules/rostests/apitests/mountmgr/testlist.c @@ -1,10 +1,12 @@ #define STANDALONE #include <apitest.h> +extern void func_QueryDosVolumePaths(void); extern void func_QueryPoints(void); const struct test winetest_testlist[] = { + { "QueryDosVolumePaths", func_QueryDosVolumePaths }, { "QueryPoints", func_QueryPoints }, { 0, 0 } }; diff --git a/modules/rostests/apitests/mountmgr/utils.c b/modules/rostests/apitests/mountmgr/utils.c index 50755581f04..7fa0794d2aa 100644 --- a/modules/rostests/apitests/mountmgr/utils.c +++ b/modules/rostests/apitests/mountmgr/utils.c @@ -47,3 +47,56 @@ GetMountMgrHandle(VOID) return MountMgrHandle; } + +VOID +DumpBuffer( + _In_ PVOID Buffer, + _In_ ULONG Length) +{ +#define LINE_SIZE (75 + 2) + ULONG i; + PBYTE Ptr1, Ptr2; + CHAR LineBuffer[LINE_SIZE]; + PCHAR Line; + ULONG LineSize; + + Ptr1 = Ptr2 = Buffer; + while ((ULONG_PTR)Buffer + Length - (ULONG_PTR)Ptr1 > 0) + { + Ptr1 = Ptr2; + Line = LineBuffer; + + /* Print the address */ + Line += _snprintf(Line, LINE_SIZE + LineBuffer - Line, "%08Ix ", (ULONG_PTR)Ptr1); + + /* Print up to 16 bytes... */ + + /* ... in hexadecimal form first... */ + i = 0; + while (i++ <= 0x0F && ((ULONG_PTR)Buffer + Length - (ULONG_PTR)Ptr1 > 0)) + { + Line += _snprintf(Line, LINE_SIZE + LineBuffer - Line, " %02x", *Ptr1); + ++Ptr1; + } + + /* ... align with spaces if needed... */ + RtlFillMemory(Line, (0x0F + 2 - i) * 3 + 2, ' '); + Line += (0x0F + 2 - i) * 3 + 2; + + /* ... then in character form. */ + i = 0; + while (i++ <= 0x0F && ((ULONG_PTR)Buffer + Length - (ULONG_PTR)Ptr2 > 0)) + { + *Line++ = ((*Ptr2 >= 0x20 && *Ptr2 <= 0x7E) || (*Ptr2 >= 0x80 && *Ptr2 < 0xFF) ? *Ptr2 : '.'); + ++Ptr2; + } + + /* Newline */ + *Line++ = '\r'; + *Line++ = '\n'; + + /* Finally display the line */ + LineSize = Line - LineBuffer; + printf("%.*s", (int)LineSize, LineBuffer); + } +}

2 weeks, 1 day

[reactos] 02/11: [MOUNTMGR_APITEST] Improve QueryPoints.c test (#6990)

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=bb264f6828bfeabb1487c… commit bb264f6828bfeabb1487c47a625bc1880c99c223 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Mon Jan 6 21:51:08 2025 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Tue Jan 21 19:15:57 2025 +0100 [MOUNTMGR_APITEST] Improve QueryPoints.c test (#6990) - Use %lu instead of %lx for printf-ing last-errors; - Don't call GetLastError() within ok, or after a previous invocation, when the aim is to retrieve the last-error set by a tested API. Instead, store its value in a local variable, that is then used in the ok() tests. - Use win_skip() only for functionality that _may_ not be implemented in Windows/ReactOS yet, but not for unexpected situations leading to tests being skipped. - Add comments; improve buffer size specifications. - Reformat the file license header. --- modules/rostests/apitests/mountmgr/QueryPoints.c | 86 +++++++++++++----------- 1 file changed, 45 insertions(+), 41 deletions(-) diff --git a/modules/rostests/apitests/mountmgr/QueryPoints.c b/modules/rostests/apitests/mountmgr/QueryPoints.c index a56b1496606..ad6b433878d 100644 --- a/modules/rostests/apitests/mountmgr/QueryPoints.c +++ b/modules/rostests/apitests/mountmgr/QueryPoints.c @@ -1,68 +1,75 @@ /* - * PROJECT: ReactOS api tests - * LICENSE: GPLv2+ - See COPYING in the top level directory - * PURPOSE: Test for QueryPoints IOCTL - * PROGRAMMER: Pierre Schweitzer + * PROJECT: ReactOS API Tests + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Test for IOCTL_MOUNTMGR_QUERY_POINTS + * COPYRIGHT: Copyright 2019 Pierre Schweitzer <pierre(a)reactos.org> */ #include "precomp.h" VOID -TraceMountPoint(PMOUNTMGR_MOUNT_POINTS MountPoints, - PMOUNTMGR_MOUNT_POINT MountPoint) +TraceMountPoint( + _In_ const MOUNTMGR_MOUNT_POINTS* MountPoints, + _In_ const MOUNTMGR_MOUNT_POINT* MountPoint) { trace("MountPoint: %p\n", MountPoint); trace("\tSymbolicOffset: %ld\n", MountPoint->SymbolicLinkNameOffset); - trace("\tSymbolicLinkName: %.*S\n", MountPoint->SymbolicLinkNameLength / sizeof(WCHAR), (PWSTR)((ULONG_PTR)MountPoints + MountPoint->SymbolicLinkNameOffset)); + trace("\tSymbolicLinkName: %.*S\n", + MountPoint->SymbolicLinkNameLength / sizeof(WCHAR), + (PWCHAR)((ULONG_PTR)MountPoints + MountPoint->SymbolicLinkNameOffset)); trace("\tDeviceOffset: %ld\n", MountPoint->DeviceNameOffset); - trace("\tDeviceName: %.*S\n", MountPoint->DeviceNameLength / sizeof(WCHAR), (PWSTR)((ULONG_PTR)MountPoints + MountPoint->DeviceNameOffset)); + trace("\tDeviceName: %.*S\n", + MountPoint->DeviceNameLength / sizeof(WCHAR), + (PWCHAR)((ULONG_PTR)MountPoints + MountPoint->DeviceNameOffset)); } START_TEST(QueryPoints) { BOOL Ret; HANDLE MountMgrHandle; - DWORD BytesReturned, Drives, i; - struct { + DWORD LastError, BytesReturned, Drives, i; + struct + { MOUNTMGR_MOUNT_POINT; - WCHAR Buffer[sizeof(L"\\DosDevice\\A:")]; + WCHAR Buffer[sizeof("\\DosDevice\\A:")]; } SinglePoint; MOUNTMGR_MOUNT_POINTS MountPoints; PMOUNTMGR_MOUNT_POINTS AllocatedPoints; - MountMgrHandle = CreateFileW(MOUNTMGR_DOS_DEVICE_NAME, 0, - FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, - OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, - INVALID_HANDLE_VALUE); - if (MountMgrHandle == INVALID_HANDLE_VALUE) + MountMgrHandle = GetMountMgrHandle(); + if (!MountMgrHandle) { - win_skip("MountMgr unavailable: %lx\n", GetLastError()); + win_skip("MountMgr unavailable: %lu\n", GetLastError()); return; } ZeroMemory(&SinglePoint, sizeof(SinglePoint)); + /* Retrieve the size needed to enumerate all the existing mount points */ Ret = DeviceIoControl(MountMgrHandle, IOCTL_MOUNTMGR_QUERY_POINTS, - &SinglePoint, sizeof(MOUNTMGR_MOUNT_POINT), - &MountPoints, sizeof(MOUNTMGR_MOUNT_POINTS), + &SinglePoint, sizeof(MOUNTMGR_MOUNT_POINT), // Size without the string. + &MountPoints, sizeof(MountPoints), &BytesReturned, NULL); - ok(Ret == FALSE, "IOCTL unexpectedly succeed\n"); - ok(GetLastError() == ERROR_MORE_DATA, "Unexcepted failure: %lx\n", GetLastError()); + LastError = GetLastError(); + ok(Ret == FALSE, "IOCTL unexpectedly succeeded\n"); + ok(LastError == ERROR_MORE_DATA, "Unexpected failure: %lu\n", LastError); + /* Allocate a suitably-sized buffer for the mount points */ AllocatedPoints = RtlAllocateHeap(RtlGetProcessHeap(), 0, MountPoints.Size); if (AllocatedPoints == NULL) { - win_skip("Insufficiant memory\n"); + skip("Insufficient memory\n"); } else { AllocatedPoints->NumberOfMountPoints = 0; + /* Retrieve the list of all the existing mount points */ Ret = DeviceIoControl(MountMgrHandle, IOCTL_MOUNTMGR_QUERY_POINTS, - &SinglePoint, sizeof(MOUNTMGR_MOUNT_POINT), + &SinglePoint, sizeof(MOUNTMGR_MOUNT_POINT), // Size without the string. AllocatedPoints, MountPoints.Size, &BytesReturned, NULL); - ok(Ret == TRUE, "IOCTL unexpectedly failed %lx\n", GetLastError()); + ok(Ret == TRUE, "IOCTL unexpectedly failed: %lu\n", GetLastError()); for (i = 0; i < AllocatedPoints->NumberOfMountPoints; ++i) { @@ -72,40 +79,37 @@ START_TEST(QueryPoints) RtlFreeHeap(RtlGetProcessHeap(), 0, AllocatedPoints); } + /* Now, find the first unused drive letter */ Drives = GetLogicalDrives(); if (Drives == 0) { - win_skip("Drives map unavailable: %lx\n", GetLastError()); + skip("Drives map unavailable: %lu\n", GetLastError()); goto Done; } - - for (i = 0; i < 26; i++) + for (i = 0; i <= 'Z'-'A'; ++i) { if (!(Drives & (1 << i))) - { break; - } } - - if (i == 26) + if (i > 'Z'-'A') { - win_skip("All the drive letters are in use, skipping\n"); + skip("All the drive letters are in use, skipping\n"); goto Done; } - SinglePoint.SymbolicLinkNameOffset = sizeof(MOUNTMGR_MOUNT_POINT); - SinglePoint.SymbolicLinkNameLength = sizeof(L"\\DosDevice\\A:") - sizeof(UNICODE_NULL); - StringCbPrintfW((PWSTR)((ULONG_PTR)&SinglePoint + sizeof(MOUNTMGR_MOUNT_POINT)), - sizeof(L"\\DosDevice\\A:"), - L"\\DosDevice\\%C:", - i + L'A'); + /* Check that this drive letter is not an existing mount point */ + SinglePoint.SymbolicLinkNameOffset = ((ULONG_PTR)&SinglePoint.Buffer - (ULONG_PTR)&SinglePoint); + SinglePoint.SymbolicLinkNameLength = sizeof(SinglePoint.Buffer) - sizeof(UNICODE_NULL); + StringCbPrintfW(SinglePoint.Buffer, sizeof(SinglePoint.Buffer), + L"\\DosDevice\\%C:", L'A' + i); Ret = DeviceIoControl(MountMgrHandle, IOCTL_MOUNTMGR_QUERY_POINTS, &SinglePoint, sizeof(SinglePoint), - &MountPoints, sizeof(MOUNTMGR_MOUNT_POINTS), + &MountPoints, sizeof(MountPoints), &BytesReturned, NULL); - ok(Ret == FALSE, "IOCTL unexpectedly succeed\n"); - ok(GetLastError() == ERROR_FILE_NOT_FOUND, "Unexcepted failure: %lx\n", GetLastError()); + LastError = GetLastError(); + ok(Ret == FALSE, "IOCTL unexpectedly succeeded\n"); + ok(LastError == ERROR_FILE_NOT_FOUND, "Unexpected failure: %lu\n", LastError); Done: CloseHandle(MountMgrHandle);

2 weeks, 1 day

[reactos] 01/11: [MOUNTMGR_APITEST] Add utils.c for some utility functions (#6990)

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=2da5db933cc0510f1e80c… commit 2da5db933cc0510f1e80c873b33c79d0bd2a9e61 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Mon Jan 6 21:51:57 2025 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Tue Jan 21 19:15:50 2025 +0100 [MOUNTMGR_APITEST] Add utils.c for some utility functions (#6990) And update the precompiled header. --- modules/rostests/apitests/mountmgr/CMakeLists.txt | 6 +-- modules/rostests/apitests/mountmgr/precomp.h | 30 ++++++++++---- modules/rostests/apitests/mountmgr/utils.c | 49 +++++++++++++++++++++++ 3 files changed, 75 insertions(+), 10 deletions(-) diff --git a/modules/rostests/apitests/mountmgr/CMakeLists.txt b/modules/rostests/apitests/mountmgr/CMakeLists.txt index 4c499c26a98..dbba2775f56 100644 --- a/modules/rostests/apitests/mountmgr/CMakeLists.txt +++ b/modules/rostests/apitests/mountmgr/CMakeLists.txt @@ -1,6 +1,7 @@ list(APPEND SOURCE - QueryPoints.c) + QueryPoints.c + utils.c) list(APPEND PCH_SKIP_SOURCE testlist.c) @@ -9,9 +10,8 @@ add_executable(mountmgr_apitest ${SOURCE} ${PCH_SKIP_SOURCE}) +add_pch(mountmgr_apitest precomp.h "${PCH_SKIP_SOURCE}") target_link_libraries(mountmgr_apitest wine ${PSEH_LIB}) set_module_type(mountmgr_apitest win32cui) add_importlibs(mountmgr_apitest msvcrt kernel32 ntdll) -# TODO: Enable this when we get more than one source file to justify its use -#add_pch(mountmgr_apitest precomp.h "${PCH_SKIP_SOURCE}") add_rostests_file(TARGET mountmgr_apitest) diff --git a/modules/rostests/apitests/mountmgr/precomp.h b/modules/rostests/apitests/mountmgr/precomp.h index 33509fb8083..462f62e1a38 100644 --- a/modules/rostests/apitests/mountmgr/precomp.h +++ b/modules/rostests/apitests/mountmgr/precomp.h @@ -1,12 +1,28 @@ -#ifndef _MOUNTMGR_APITEST_PRECOMP_H_ -#define _MOUNTMGR_APITEST_PRECOMP_H_ +/* + * PROJECT: ReactOS API Tests + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Precompiled header + * COPYRIGHT: Copyright 2019 Pierre Schweitzer <pierre(a)reactos.org> + * Copyright 2025 Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> + */ -#define WIN32_NO_STATUS +#pragma once +#define WIN32_NO_STATUS #include <apitest.h> -#include <strsafe.h> -#include <ntstatus.h> -#include <mountmgr.h> + +#define NTOS_MODE_USER +#include <ndk/iofuncs.h> #include <ndk/rtlfuncs.h> -#endif /* _MOUNTMGR_APITEST_PRECOMP_H_ */ +#include <mountmgr.h> +#include <strsafe.h> + +/* utils.c */ + +LPCSTR wine_dbgstr_us(const UNICODE_STRING *us); + +HANDLE +GetMountMgrHandle(VOID); + +/* EOF */ diff --git a/modules/rostests/apitests/mountmgr/utils.c b/modules/rostests/apitests/mountmgr/utils.c new file mode 100644 index 00000000000..50755581f04 --- /dev/null +++ b/modules/rostests/apitests/mountmgr/utils.c @@ -0,0 +1,49 @@ +/* + * PROJECT: ReactOS API Tests + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Utility functions + * COPYRIGHT: Copyright 2025 Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> + */ + +#include "precomp.h" + +LPCSTR wine_dbgstr_us(const UNICODE_STRING *us) +{ + if (!us) return "(null)"; + return wine_dbgstr_wn(us->Buffer, us->Length / sizeof(WCHAR)); +} + +/** + * @brief + * Retrieves a handle to the MountMgr controlling device. + * The handle should be closed with NtClose() once it is no longer in use. + **/ +HANDLE +GetMountMgrHandle(VOID) +{ + NTSTATUS Status; + UNICODE_STRING MountMgrDevice; + OBJECT_ATTRIBUTES ObjectAttributes; + IO_STATUS_BLOCK IoStatusBlock; + HANDLE MountMgrHandle = NULL; + + RtlInitUnicodeString(&MountMgrDevice, MOUNTMGR_DEVICE_NAME); + InitializeObjectAttributes(&ObjectAttributes, + &MountMgrDevice, + OBJ_CASE_INSENSITIVE, + NULL, + NULL); + Status = NtOpenFile(&MountMgrHandle, + FILE_READ_ATTRIBUTES | SYNCHRONIZE, + &ObjectAttributes, + &IoStatusBlock, + FILE_SHARE_READ | FILE_SHARE_WRITE, + FILE_SYNCHRONOUS_IO_NONALERT); + if (!NT_SUCCESS(Status)) + { + winetest_print("NtOpenFile(%s) failed, Status 0x%08lx\n", + wine_dbgstr_us(&MountMgrDevice), Status); + } + + return MountMgrHandle; +}

2 weeks, 1 day

← Newer
1
...
10
11
12
13
14
15
16
...
28
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs January 2025