Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-03 14:56:31 +00:00
Code Issues Projects Releases Packages Wiki Activity

[KERNEL32]

Browse source 
W2K3ify GetVolumeInformationA().
Also fix a regression brought by GetVolumeInformationW() rewrite (yay, winetests!).

svn path=/trunk/; revision=75969
This commit is contained in:
Pierre Schweitzer 2017-09-26 06:18:07 +00:00
parent 6b45a088f3
commit 45b7500fd9
1 changed files with 92 additions and 103 deletions
Download patch file Download diff file Expand all files Collapse all files

195
reactos/dll/win32/kernel32/client/file/volume.c
View file

@ -85,124 +85,113 @@ GetVolumeInformationA(IN LPCSTR lpRootPathName,
OUT LPSTR lpFileSystemNameBuffer OPTIONAL, OUT LPSTR lpFileSystemNameBuffer OPTIONAL,
IN DWORD nFileSystemNameSize) IN DWORD nFileSystemNameSize)
{ {
UNICODE_STRING FileSystemNameU; BOOL Ret;
UNICODE_STRING VolumeNameU = { 0, 0, NULL }; NTSTATUS Status;
ANSI_STRING VolumeName; PUNICODE_STRING RootPathNameU;
ANSI_STRING FileSystemName; ANSI_STRING VolumeName, FileSystemName;
PWCHAR RootPathNameW; UNICODE_STRING VolumeNameU, FileSystemNameU;
BOOL Result;
if (!(RootPathNameW = FilenameA2W(lpRootPathName, FALSE))) /* If no root path provided, default to \ */
return FALSE; if (lpRootPathName == NULL)
if (lpVolumeNameBuffer)
{ {
VolumeNameU.MaximumLength = (USHORT)nVolumeNameSize * sizeof(WCHAR); lpRootPathName = "\\";
VolumeNameU.Buffer = RtlAllocateHeap (RtlGetProcessHeap (),
0,
VolumeNameU.MaximumLength);
if (VolumeNameU.Buffer == NULL)
{
goto FailNoMem;
}
} }
if (lpFileSystemNameBuffer) /* Convert root path to unicode */
RootPathNameU = Basep8BitStringToStaticUnicodeString(lpRootPathName);
if (RootPathNameU == NULL)
{ {
FileSystemNameU.Length = 0; return FALSE;
FileSystemNameU.MaximumLength = (USHORT)nFileSystemNameSize * sizeof(WCHAR);
FileSystemNameU.Buffer = RtlAllocateHeap (RtlGetProcessHeap (),
0,
FileSystemNameU.MaximumLength);
if (FileSystemNameU.Buffer == NULL)
{
if (VolumeNameU.Buffer != NULL)
{
RtlFreeHeap(RtlGetProcessHeap(),
0,
VolumeNameU.Buffer);
}
FailNoMem:
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
} }
Result = GetVolumeInformationW (RootPathNameW, /* Init all our STRINGS (U/A) */
lpVolumeNameBuffer ? VolumeNameU.Buffer : NULL, VolumeNameU.Buffer = NULL;
nVolumeNameSize, VolumeNameU.MaximumLength = 0;
lpVolumeSerialNumber, FileSystemNameU.Buffer = NULL;
lpMaximumComponentLength, FileSystemNameU.MaximumLength = 0;
lpFileSystemFlags,
lpFileSystemNameBuffer ? FileSystemNameU.Buffer : NULL,
nFileSystemNameSize);
if (Result) VolumeName.Buffer = lpVolumeNameBuffer;
VolumeName.MaximumLength = nVolumeNameSize + 1;
FileSystemName.Buffer = lpFileSystemNameBuffer;
FileSystemName.MaximumLength = nFileSystemNameSize + 1;
/* Assume failure for now */
Ret = FALSE;
/* If caller wants volume name, allocate a buffer to receive it */
if (lpVolumeNameBuffer != NULL)
{ {
if (lpVolumeNameBuffer) VolumeNameU.MaximumLength = sizeof(WCHAR) * (nVolumeNameSize + 1);
VolumeNameU.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0,
VolumeNameU.MaximumLength);
if (VolumeNameU.Buffer == NULL)
{ {
VolumeNameU.Length = wcslen(VolumeNameU.Buffer) * sizeof(WCHAR); SetLastError(ERROR_NOT_ENOUGH_MEMORY);
VolumeName.Length = 0; goto CleanAndQuit;
VolumeName.MaximumLength = (USHORT)nVolumeNameSize; }
VolumeName.Buffer = lpVolumeNameBuffer;
}
if (lpFileSystemNameBuffer)
{
FileSystemNameU.Length = wcslen(FileSystemNameU.Buffer) * sizeof(WCHAR);
FileSystemName.Length = 0;
FileSystemName.MaximumLength = (USHORT)nFileSystemNameSize;
FileSystemName.Buffer = lpFileSystemNameBuffer;
}
/* convert unicode strings to ansi (or oem) */
if (bIsFileApiAnsi)
{
if (lpVolumeNameBuffer)
{
RtlUnicodeStringToAnsiString (&VolumeName,
&VolumeNameU,
FALSE);
}
if (lpFileSystemNameBuffer)
{
RtlUnicodeStringToAnsiString (&FileSystemName,
&FileSystemNameU,
FALSE);
}
}
else
{
if (lpVolumeNameBuffer)
{
RtlUnicodeStringToOemString (&VolumeName,
&VolumeNameU,
FALSE);
}
if (lpFileSystemNameBuffer)
{
RtlUnicodeStringToOemString (&FileSystemName,
&FileSystemNameU,
FALSE);
}
}
} }
if (lpVolumeNameBuffer) /* If caller wants file system name, allocate a buffer to receive it */
if (lpFileSystemNameBuffer != NULL)
{ {
RtlFreeHeap (RtlGetProcessHeap (), FileSystemNameU.MaximumLength = sizeof(WCHAR) * (nVolumeNameSize + 1);
0, FileSystemNameU.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0,
VolumeNameU.Buffer); FileSystemNameU.MaximumLength);
} if (FileSystemNameU.Buffer == NULL)
if (lpFileSystemNameBuffer) {
{ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
RtlFreeHeap (RtlGetProcessHeap (), goto CleanAndQuit;
0, }
FileSystemNameU.Buffer);
} }
return Result; /* Call W */
Ret = GetVolumeInformationW(RootPathNameU->Buffer, VolumeNameU.Buffer,
nVolumeNameSize, lpVolumeSerialNumber,
lpMaximumComponentLength, lpFileSystemFlags,
FileSystemNameU.Buffer, nFileSystemNameSize);
/* If it succeed, convert back to ANSI */
if (Ret)
{
if (lpVolumeNameBuffer != NULL)
{
RtlInitUnicodeString(&VolumeNameU, VolumeNameU.Buffer);
Status = RtlUnicodeStringToAnsiString(&VolumeName, &VolumeNameU, FALSE);
if (!NT_SUCCESS(Status))
{
BaseSetLastNTError(Status);
Ret = FALSE;
goto CleanAndQuit;
}
}
if (lpFileSystemNameBuffer != NULL)
{
RtlInitUnicodeString(&FileSystemNameU, FileSystemNameU.Buffer);
Status = RtlUnicodeStringToAnsiString(&FileSystemName, &FileSystemNameU, FALSE);
if (!NT_SUCCESS(Status))
{
BaseSetLastNTError(Status);
Ret = FALSE;
goto CleanAndQuit;
}
}
}
/* Clean and quit */
CleanAndQuit:
if (VolumeNameU.Buffer != NULL)
{
RtlFreeHeap(RtlGetProcessHeap(), 0, VolumeNameU.Buffer);
}
if (FileSystemNameU.Buffer != NULL)
{
RtlFreeHeap(RtlGetProcessHeap(), 0, FileSystemNameU.Buffer);
}
return Ret;
} }
/* /*