[ros-diffs] [rharabien] 51486: [KERNEL32] * Fix formatting. No code changes.

Author: rharabien
Date: Thu Apr 28 22:33:50 2011
New Revision: 51486

URL: http://svn.reactos.org/svn/reactos?rev=51486&view=rev
Log:
[KERNEL32]
* Fix formatting. No code changes.

Modified:
    trunk/reactos/dll/win32/kernel32/file/volume.c

Modified: trunk/reactos/dll/win32/kernel32/file/volume.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/file/vo…
==============================================================================
--- trunk/reactos/dll/win32/kernel32/file/volume.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/kernel32/file/volume.c [iso-8859-1] Thu Apr 28 22:33:50 2011
@@ -29,41 +29,41 @@
 
 static HANDLE
 InternalOpenDirW(LPCWSTR DirName,
-		 BOOLEAN Write)
-{
-  UNICODE_STRING NtPathU;
-  OBJECT_ATTRIBUTES ObjectAttributes;
-  NTSTATUS errCode;
-  IO_STATUS_BLOCK IoStatusBlock;
-  HANDLE hFile;
-
-  if (!RtlDosPathNameToNtPathName_U(DirName,
-				    &NtPathU,
-				    NULL,
-				    NULL))
-    {
-	WARN("Invalid path\n");
-	SetLastError(ERROR_BAD_PATHNAME);
-	return INVALID_HANDLE_VALUE;
+                 BOOLEAN Write)
+{
+    UNICODE_STRING NtPathU;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    NTSTATUS errCode;
+    IO_STATUS_BLOCK IoStatusBlock;
+    HANDLE hFile;
+
+    if (!RtlDosPathNameToNtPathName_U(DirName,
+                                      &NtPathU,
+                                      NULL,
+                                      NULL))
+    {
+        WARN("Invalid path\n");
+        SetLastError(ERROR_BAD_PATHNAME);
+        return INVALID_HANDLE_VALUE;
     }
 
     InitializeObjectAttributes(&ObjectAttributes,
-	                       &NtPathU,
-			       OBJ_CASE_INSENSITIVE,
-			       NULL,
-			       NULL);
+                               &NtPathU,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
 
     errCode = NtCreateFile (&hFile,
-	                    Write ? FILE_GENERIC_WRITE : FILE_GENERIC_READ,
-			    &ObjectAttributes,
-			    &IoStatusBlock,
-			    NULL,
-			    0,
-			    FILE_SHARE_READ|FILE_SHARE_WRITE,
-			    FILE_OPEN,
-			    0,
-			    NULL,
-			    0);
+                            Write ? FILE_GENERIC_WRITE : FILE_GENERIC_READ,
+                            &ObjectAttributes,
+                            &IoStatusBlock,
+                            NULL,
+                            0,
+                            FILE_SHARE_READ|FILE_SHARE_WRITE,
+                            FILE_OPEN,
+                            0,
+                            NULL,
+                            0);
 
     RtlFreeHeap(RtlGetProcessHeap(),
                 0,
@@ -71,8 +71,8 @@
 
     if (!NT_SUCCESS(errCode))
     {
-	SetLastErrorByStatus (errCode);
-	return INVALID_HANDLE_VALUE;
+        SetLastErrorByStatus (errCode);
+        return INVALID_HANDLE_VALUE;
     }
     return hFile;
 }
@@ -84,34 +84,34 @@
 /* Synced to Wine-2008/12/28 */
 DWORD WINAPI
 GetLogicalDriveStringsA(DWORD nBufferLength,
-			LPSTR lpBuffer)
-{
-   DWORD drive, count;
-   DWORD dwDriveMap;
-   LPSTR p;
-
-   dwDriveMap = GetLogicalDrives();
-
-   for (drive = count = 0; drive < MAX_DOS_DRIVES; drive++)
-     {
-	if (dwDriveMap & (1<<drive))
-	   count++;
-     }
-
-
-   if ((count * 4) + 1 > nBufferLength) return ((count * 4) + 1);
-
-	p = lpBuffer;
-
-	for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
-	  if (dwDriveMap & (1<<drive))
-	  {
-	     *p++ = 'A' + (UCHAR)drive;
-	     *p++ = ':';
-	     *p++ = '\\';
-	     *p++ = '\0';
-	  }
-	*p = '\0';
+                        LPSTR lpBuffer)
+{
+    DWORD drive, count;
+    DWORD dwDriveMap;
+    LPSTR p;
+
+    dwDriveMap = GetLogicalDrives();
+
+    for (drive = count = 0; drive < MAX_DOS_DRIVES; drive++)
+    {
+        if (dwDriveMap & (1<<drive))
+            count++;
+    }
+
+
+    if ((count * 4) + 1 > nBufferLength) return ((count * 4) + 1);
+
+    p = lpBuffer;
+
+    for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
+        if (dwDriveMap & (1<<drive))
+        {
+            *p++ = 'A' + (UCHAR)drive;
+            *p++ = ':';
+            *p++ = '\\';
+            *p++ = '\0';
+        }
+    *p = '\0';
 
     return (count * 4);
 }
@@ -123,19 +123,19 @@
 /* Synced to Wine-2008/12/28 */
 DWORD WINAPI
 GetLogicalDriveStringsW(DWORD nBufferLength,
-			LPWSTR lpBuffer)
-{
-   DWORD drive, count;
-   DWORD dwDriveMap;
-   LPWSTR p;
-
-   dwDriveMap = GetLogicalDrives();
-
-   for (drive = count = 0; drive < MAX_DOS_DRIVES; drive++)
-     {
-	if (dwDriveMap & (1<<drive))
-	   count++;
-     }
+                        LPWSTR lpBuffer)
+{
+    DWORD drive, count;
+    DWORD dwDriveMap;
+    LPWSTR p;
+
+    dwDriveMap = GetLogicalDrives();
+
+    for (drive = count = 0; drive < MAX_DOS_DRIVES; drive++)
+    {
+        if (dwDriveMap & (1<<drive))
+            count++;
+    }
 
     if ((count * 4) + 1 > nBufferLength) return ((count * 4) + 1);
 
@@ -161,24 +161,24 @@
 DWORD WINAPI
 GetLogicalDrives(VOID)
 {
-	NTSTATUS Status;
-	PROCESS_DEVICEMAP_INFORMATION ProcessDeviceMapInfo;
-
-	/* Get the Device Map for this Process */
-	Status = NtQueryInformationProcess(NtCurrentProcess(),
-					   ProcessDeviceMap,
-					   &ProcessDeviceMapInfo,
-					   sizeof(ProcessDeviceMapInfo),
-					   NULL);
-
-	/* Return the Drive Map */
-	if (!NT_SUCCESS(Status))
-	{
-		SetLastErrorByStatus(Status);
-		return 0;
-	}
-
-        return ProcessDeviceMapInfo.Query.DriveMap;
+    NTSTATUS Status;
+    PROCESS_DEVICEMAP_INFORMATION ProcessDeviceMapInfo;
+
+    /* Get the Device Map for this Process */
+    Status = NtQueryInformationProcess(NtCurrentProcess(),
+                                       ProcessDeviceMap,
+                                       &ProcessDeviceMapInfo,
+                                       sizeof(ProcessDeviceMapInfo),
+                                       NULL);
+
+    /* Return the Drive Map */
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastErrorByStatus(Status);
+        return 0;
+    }
+
+    return ProcessDeviceMapInfo.Query.DriveMap;
 }
 
 
@@ -187,26 +187,26 @@
  */
 BOOL WINAPI
 GetDiskFreeSpaceA (
-	LPCSTR	lpRootPathName,
-	LPDWORD	lpSectorsPerCluster,
-	LPDWORD	lpBytesPerSector,
-	LPDWORD	lpNumberOfFreeClusters,
-	LPDWORD	lpTotalNumberOfClusters
-	)
-{
-   PWCHAR RootPathNameW=NULL;
-
-   if (lpRootPathName)
-   {
-      if (!(RootPathNameW = FilenameA2W(lpRootPathName, FALSE)))
-         return FALSE;
-   }
-
-	return GetDiskFreeSpaceW (RootPathNameW,
-	                            lpSectorsPerCluster,
-	                            lpBytesPerSector,
-	                            lpNumberOfFreeClusters,
-	                            lpTotalNumberOfClusters);
+    LPCSTR	lpRootPathName,
+    LPDWORD	lpSectorsPerCluster,
+    LPDWORD	lpBytesPerSector,
+    LPDWORD	lpNumberOfFreeClusters,
+    LPDWORD	lpTotalNumberOfClusters
+)
+{
+    PWCHAR RootPathNameW=NULL;
+
+    if (lpRootPathName)
+    {
+        if (!(RootPathNameW = FilenameA2W(lpRootPathName, FALSE)))
+            return FALSE;
+    }
+
+    return GetDiskFreeSpaceW (RootPathNameW,
+                              lpSectorsPerCluster,
+                              lpBytesPerSector,
+                              lpNumberOfFreeClusters,
+                              lpTotalNumberOfClusters);
 }
 
 
@@ -220,7 +220,7 @@
     LPDWORD lpBytesPerSector,
     LPDWORD lpNumberOfFreeClusters,
     LPDWORD lpTotalNumberOfClusters
-    )
+)
 {
     FILE_FS_SIZE_INFORMATION FileFsSize;
     IO_STATUS_BLOCK IoStatusBlock;
@@ -238,11 +238,11 @@
     }
     RootPathName[3] = 0;
 
-  hFile = InternalOpenDirW(RootPathName, FALSE);
-  if (INVALID_HANDLE_VALUE == hFile)
-    {
-      SetLastError(ERROR_PATH_NOT_FOUND);
-      return FALSE;
+    hFile = InternalOpenDirW(RootPathName, FALSE);
+    if (INVALID_HANDLE_VALUE == hFile)
+    {
+        SetLastError(ERROR_PATH_NOT_FOUND);
+        return FALSE;
     }
 
     errCode = NtQueryVolumeInformationFile(hFile,
@@ -276,24 +276,24 @@
  */
 BOOL WINAPI
 GetDiskFreeSpaceExA (
-	LPCSTR lpDirectoryName   OPTIONAL,
-	PULARGE_INTEGER	lpFreeBytesAvailableToCaller,
-	PULARGE_INTEGER	lpTotalNumberOfBytes,
-	PULARGE_INTEGER	lpTotalNumberOfFreeBytes
-	)
-{
-   PWCHAR DirectoryNameW=NULL;
-
-	if (lpDirectoryName)
-	{
-      if (!(DirectoryNameW = FilenameA2W(lpDirectoryName, FALSE)))
-         return FALSE;
-	}
-
-   return GetDiskFreeSpaceExW (DirectoryNameW ,
-	                              lpFreeBytesAvailableToCaller,
-	                              lpTotalNumberOfBytes,
-	                              lpTotalNumberOfFreeBytes);
+    LPCSTR lpDirectoryName   OPTIONAL,
+    PULARGE_INTEGER	lpFreeBytesAvailableToCaller,
+    PULARGE_INTEGER	lpTotalNumberOfBytes,
+    PULARGE_INTEGER	lpTotalNumberOfFreeBytes
+)
+{
+    PWCHAR DirectoryNameW=NULL;
+
+    if (lpDirectoryName)
+    {
+        if (!(DirectoryNameW = FilenameA2W(lpDirectoryName, FALSE)))
+            return FALSE;
+    }
+
+    return GetDiskFreeSpaceExW (DirectoryNameW ,
+                                lpFreeBytesAvailableToCaller,
+                                lpTotalNumberOfBytes,
+                                lpTotalNumberOfFreeBytes);
 }
 
 
@@ -306,7 +306,7 @@
     PULARGE_INTEGER lpFreeBytesAvailableToCaller,
     PULARGE_INTEGER lpTotalNumberOfBytes,
     PULARGE_INTEGER lpTotalNumberOfFreeBytes
-    )
+)
 {
     union
     {
@@ -417,12 +417,12 @@
 UINT WINAPI
 GetDriveTypeA(LPCSTR lpRootPathName)
 {
-   PWCHAR RootPathNameW;
-
-   if (!(RootPathNameW = FilenameA2W(lpRootPathName, FALSE)))
-      return DRIVE_UNKNOWN;
-
-   return GetDriveTypeW(RootPathNameW);
+    PWCHAR RootPathNameW;
+
+    if (!(RootPathNameW = FilenameA2W(lpRootPathName, FALSE)))
+        return DRIVE_UNKNOWN;
+
+    return GetDriveTypeW(RootPathNameW);
 }
 
 
@@ -432,10 +432,10 @@
 UINT WINAPI
 GetDriveTypeW(LPCWSTR lpRootPathName)
 {
-	FILE_FS_DEVICE_INFORMATION FileFsDevice;
-	IO_STATUS_BLOCK IoStatusBlock;
-	HANDLE hFile;
-	NTSTATUS Status;
+    FILE_FS_DEVICE_INFORMATION FileFsDevice;
+    IO_STATUS_BLOCK IoStatusBlock;
+    HANDLE hFile;
+    NTSTATUS Status;
     UNICODE_STRING NtPath;
     OBJECT_ATTRIBUTES ObjectAttributes;
     WCHAR Buffer[MAX_PATH+1];
@@ -443,7 +443,7 @@
     if (!lpRootPathName)
     {
         DWORD cBytes;
-        
+
         /* Get current directory */
         cBytes = RtlGetCurrentDirectory_U(sizeof(Buffer), Buffer);
         if(cBytes < sizeof(Buffer))
@@ -473,10 +473,10 @@
     NtPath.Length -= sizeof(WCHAR);
 
     InitializeObjectAttributes(&ObjectAttributes,
-	                           &NtPath,
+                               &NtPath,
                                OBJ_CASE_INSENSITIVE,
                                NULL,
-			                   NULL);
+                               NULL);
 
     Status = NtCreateFile(&hFile,
                           FILE_GENERIC_READ,
@@ -498,39 +498,39 @@
         return DRIVE_NO_ROOT_DIR;	/* According to WINE regression tests */
     }
 
-	Status = NtQueryVolumeInformationFile (hFile,
-	                                       &IoStatusBlock,
-	                                       &FileFsDevice,
-	                                       sizeof(FILE_FS_DEVICE_INFORMATION),
-	                                       FileFsDeviceInformation);
-	CloseHandle(hFile);
-	if (!NT_SUCCESS(Status))
+    Status = NtQueryVolumeInformationFile (hFile,
+                                           &IoStatusBlock,
+                                           &FileFsDevice,
+                                           sizeof(FILE_FS_DEVICE_INFORMATION),
+                                           FileFsDeviceInformation);
+    CloseHandle(hFile);
+    if (!NT_SUCCESS(Status))
     {
         ERR("NtQueryVolumeInformationFile failed for %ls\n", lpRootPathName);
         return DRIVE_UNKNOWN;
     }
 
-        switch (FileFsDevice.DeviceType)
-        {
-		case FILE_DEVICE_CD_ROM:
-		case FILE_DEVICE_CD_ROM_FILE_SYSTEM:
-			return DRIVE_CDROM;
-	        case FILE_DEVICE_VIRTUAL_DISK:
-	        	return DRIVE_RAMDISK;
-	        case FILE_DEVICE_NETWORK_FILE_SYSTEM:
-	        	return DRIVE_REMOTE;
-	        case FILE_DEVICE_DISK:
-	        case FILE_DEVICE_DISK_FILE_SYSTEM:
-			if (FileFsDevice.Characteristics & FILE_REMOTE_DEVICE)
-				return DRIVE_REMOTE;
-			if (FileFsDevice.Characteristics & FILE_REMOVABLE_MEDIA)
-				return DRIVE_REMOVABLE;
-			return DRIVE_FIXED;
-        }
-
-        ERR("Returning DRIVE_UNKNOWN for device type %d\n",
FileFsDevice.DeviceType);
-
-	return DRIVE_UNKNOWN;
+    switch (FileFsDevice.DeviceType)
+    {
+    case FILE_DEVICE_CD_ROM:
+    case FILE_DEVICE_CD_ROM_FILE_SYSTEM:
+        return DRIVE_CDROM;
+    case FILE_DEVICE_VIRTUAL_DISK:
+        return DRIVE_RAMDISK;
+    case FILE_DEVICE_NETWORK_FILE_SYSTEM:
+        return DRIVE_REMOTE;
+    case FILE_DEVICE_DISK:
+    case FILE_DEVICE_DISK_FILE_SYSTEM:
+        if (FileFsDevice.Characteristics & FILE_REMOTE_DEVICE)
+            return DRIVE_REMOTE;
+        if (FileFsDevice.Characteristics & FILE_REMOVABLE_MEDIA)
+            return DRIVE_REMOVABLE;
+        return DRIVE_FIXED;
+    }
+
+    ERR("Returning DRIVE_UNKNOWN for device type %d\n",
FileFsDevice.DeviceType);
+
+    return DRIVE_UNKNOWN;
 }
 
 
@@ -539,134 +539,134 @@
  */
 BOOL WINAPI
 GetVolumeInformationA(
-	LPCSTR	lpRootPathName,
-	LPSTR	lpVolumeNameBuffer,
-	DWORD	nVolumeNameSize,
-	LPDWORD	lpVolumeSerialNumber,
-	LPDWORD	lpMaximumComponentLength,
-	LPDWORD	lpFileSystemFlags,
-	LPSTR	lpFileSystemNameBuffer,
-	DWORD	nFileSystemNameSize
-	)
-{
-  UNICODE_STRING FileSystemNameU;
-  UNICODE_STRING VolumeNameU = { 0, 0, NULL };
-  ANSI_STRING VolumeName;
-  ANSI_STRING FileSystemName;
-  PWCHAR RootPathNameW;
-  BOOL Result;
-
-  if (!(RootPathNameW = FilenameA2W(lpRootPathName, FALSE)))
-     return FALSE;
-
-  if (lpVolumeNameBuffer)
-    {
-      VolumeNameU.MaximumLength = (USHORT)nVolumeNameSize * sizeof(WCHAR);
-      VolumeNameU.Buffer = RtlAllocateHeap (RtlGetProcessHeap (),
-	                                    0,
-	                                    VolumeNameU.MaximumLength);
-      if (VolumeNameU.Buffer == NULL)
-      {
-          goto FailNoMem;
-      }
-    }
-
-  if (lpFileSystemNameBuffer)
-    {
-      FileSystemNameU.Length = 0;
-      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);
-          }
+    LPCSTR	lpRootPathName,
+    LPSTR	lpVolumeNameBuffer,
+    DWORD	nVolumeNameSize,
+    LPDWORD	lpVolumeSerialNumber,
+    LPDWORD	lpMaximumComponentLength,
+    LPDWORD	lpFileSystemFlags,
+    LPSTR	lpFileSystemNameBuffer,
+    DWORD	nFileSystemNameSize
+)
+{
+    UNICODE_STRING FileSystemNameU;
+    UNICODE_STRING VolumeNameU = { 0, 0, NULL };
+    ANSI_STRING VolumeName;
+    ANSI_STRING FileSystemName;
+    PWCHAR RootPathNameW;
+    BOOL Result;
+
+    if (!(RootPathNameW = FilenameA2W(lpRootPathName, FALSE)))
+        return FALSE;
+
+    if (lpVolumeNameBuffer)
+    {
+        VolumeNameU.MaximumLength = (USHORT)nVolumeNameSize * sizeof(WCHAR);
+        VolumeNameU.Buffer = RtlAllocateHeap (RtlGetProcessHeap (),
+                                              0,
+                                              VolumeNameU.MaximumLength);
+        if (VolumeNameU.Buffer == NULL)
+        {
+            goto FailNoMem;
+        }
+    }
+
+    if (lpFileSystemNameBuffer)
+    {
+        FileSystemNameU.Length = 0;
+        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,
-	                          lpVolumeNameBuffer ? VolumeNameU.Buffer : NULL,
-	                          nVolumeNameSize,
-	                          lpVolumeSerialNumber,
-	                          lpMaximumComponentLength,
-	                          lpFileSystemFlags,
-				  lpFileSystemNameBuffer ? FileSystemNameU.Buffer : NULL,
-	                          nFileSystemNameSize);
-
-  if (Result)
-    {
-      if (lpVolumeNameBuffer)
-        {
-          VolumeNameU.Length = wcslen(VolumeNameU.Buffer) * sizeof(WCHAR);
-	  VolumeName.Length = 0;
-	  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)
-    {
-      RtlFreeHeap (RtlGetProcessHeap (),
-	           0,
-	           VolumeNameU.Buffer);
-    }
-  if (lpFileSystemNameBuffer)
-    {
-      RtlFreeHeap (RtlGetProcessHeap (),
-	           0,
-	           FileSystemNameU.Buffer);
-    }
-
-  return Result;
+            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+            return FALSE;
+        }
+    }
+
+    Result = GetVolumeInformationW (RootPathNameW,
+                                    lpVolumeNameBuffer ? VolumeNameU.Buffer : NULL,
+                                    nVolumeNameSize,
+                                    lpVolumeSerialNumber,
+                                    lpMaximumComponentLength,
+                                    lpFileSystemFlags,
+                                    lpFileSystemNameBuffer ? FileSystemNameU.Buffer :
NULL,
+                                    nFileSystemNameSize);
+
+    if (Result)
+    {
+        if (lpVolumeNameBuffer)
+        {
+            VolumeNameU.Length = wcslen(VolumeNameU.Buffer) * sizeof(WCHAR);
+            VolumeName.Length = 0;
+            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)
+    {
+        RtlFreeHeap (RtlGetProcessHeap (),
+                     0,
+                     VolumeNameU.Buffer);
+    }
+    if (lpFileSystemNameBuffer)
+    {
+        RtlFreeHeap (RtlGetProcessHeap (),
+                     0,
+                     FileSystemNameU.Buffer);
+    }
+
+    return Result;
 }
 
 #define FS_VOLUME_BUFFER_SIZE (MAX_PATH * sizeof(WCHAR) +
sizeof(FILE_FS_VOLUME_INFORMATION))
@@ -686,106 +686,106 @@
     LPDWORD lpFileSystemFlags,
     LPWSTR lpFileSystemNameBuffer,
     DWORD nFileSystemNameSize
-    )
-{
-  PFILE_FS_VOLUME_INFORMATION FileFsVolume;
-  PFILE_FS_ATTRIBUTE_INFORMATION FileFsAttribute;
-  IO_STATUS_BLOCK IoStatusBlock;
-  WCHAR RootPathName[MAX_PATH];
-  UCHAR Buffer[max(FS_VOLUME_BUFFER_SIZE, FS_ATTRIBUTE_BUFFER_SIZE)];
-
-  HANDLE hFile;
-  NTSTATUS errCode;
-
-  FileFsVolume = (PFILE_FS_VOLUME_INFORMATION)Buffer;
-  FileFsAttribute = (PFILE_FS_ATTRIBUTE_INFORMATION)Buffer;
-
-  TRACE("FileFsVolume %p\n", FileFsVolume);
-  TRACE("FileFsAttribute %p\n", FileFsAttribute);
-
-  if (!lpRootPathName || !wcscmp(lpRootPathName, L""))
-  {
-      GetCurrentDirectoryW (MAX_PATH, RootPathName);
-  }
-  else
-  {
-      wcsncpy (RootPathName, lpRootPathName, 3);
-  }
-  RootPathName[3] = 0;
-
-  hFile = InternalOpenDirW(RootPathName, FALSE);
-  if (hFile == INVALID_HANDLE_VALUE)
-    {
-      return FALSE;
-    }
-
-  TRACE("hFile: %x\n", hFile);
-  errCode = NtQueryVolumeInformationFile(hFile,
-                                         &IoStatusBlock,
-                                         FileFsVolume,
-                                         FS_VOLUME_BUFFER_SIZE,
-                                         FileFsVolumeInformation);
-  if ( !NT_SUCCESS(errCode) )
-    {
-      WARN("Status: %x\n", errCode);
-      CloseHandle(hFile);
-      SetLastErrorByStatus (errCode);
-      return FALSE;
-    }
-
-  if (lpVolumeSerialNumber)
-    *lpVolumeSerialNumber = FileFsVolume->VolumeSerialNumber;
-
-  if (lpVolumeNameBuffer)
-    {
-      if (nVolumeNameSize * sizeof(WCHAR) >= FileFsVolume->VolumeLabelLength +
sizeof(WCHAR))
-        {
-	  memcpy(lpVolumeNameBuffer,
-		 FileFsVolume->VolumeLabel,
-		 FileFsVolume->VolumeLabelLength);
-	  lpVolumeNameBuffer[FileFsVolume->VolumeLabelLength / sizeof(WCHAR)] = 0;
-	}
-      else
-        {
-	  CloseHandle(hFile);
-	  SetLastError(ERROR_MORE_DATA);
-	  return FALSE;
-	}
-    }
-
-  errCode = NtQueryVolumeInformationFile (hFile,
-	                                  &IoStatusBlock,
-	                                  FileFsAttribute,
-	                                  FS_ATTRIBUTE_BUFFER_SIZE,
-	                                  FileFsAttributeInformation);
-  CloseHandle(hFile);
-  if (!NT_SUCCESS(errCode))
-    {
-      WARN("Status: %x\n", errCode);
-      SetLastErrorByStatus (errCode);
-      return FALSE;
-    }
-
-  if (lpFileSystemFlags)
-    *lpFileSystemFlags = FileFsAttribute->FileSystemAttributes;
-  if (lpMaximumComponentLength)
-    *lpMaximumComponentLength = FileFsAttribute->MaximumComponentNameLength;
-  if (lpFileSystemNameBuffer)
-    {
-      if (nFileSystemNameSize * sizeof(WCHAR) >=
FileFsAttribute->FileSystemNameLength + sizeof(WCHAR))
-        {
-	  memcpy(lpFileSystemNameBuffer,
-		 FileFsAttribute->FileSystemName,
-		 FileFsAttribute->FileSystemNameLength);
-	  lpFileSystemNameBuffer[FileFsAttribute->FileSystemNameLength / sizeof(WCHAR)] = 0;
-	}
-      else
-        {
-	  SetLastError(ERROR_MORE_DATA);
-	  return FALSE;
-	}
-    }
-  return TRUE;
+)
+{
+    PFILE_FS_VOLUME_INFORMATION FileFsVolume;
+    PFILE_FS_ATTRIBUTE_INFORMATION FileFsAttribute;
+    IO_STATUS_BLOCK IoStatusBlock;
+    WCHAR RootPathName[MAX_PATH];
+    UCHAR Buffer[max(FS_VOLUME_BUFFER_SIZE, FS_ATTRIBUTE_BUFFER_SIZE)];
+
+    HANDLE hFile;
+    NTSTATUS errCode;
+
+    FileFsVolume = (PFILE_FS_VOLUME_INFORMATION)Buffer;
+    FileFsAttribute = (PFILE_FS_ATTRIBUTE_INFORMATION)Buffer;
+
+    TRACE("FileFsVolume %p\n", FileFsVolume);
+    TRACE("FileFsAttribute %p\n", FileFsAttribute);
+
+    if (!lpRootPathName || !wcscmp(lpRootPathName, L""))
+    {
+        GetCurrentDirectoryW (MAX_PATH, RootPathName);
+    }
+    else
+    {
+        wcsncpy (RootPathName, lpRootPathName, 3);
+    }
+    RootPathName[3] = 0;
+
+    hFile = InternalOpenDirW(RootPathName, FALSE);
+    if (hFile == INVALID_HANDLE_VALUE)
+    {
+        return FALSE;
+    }
+
+    TRACE("hFile: %x\n", hFile);
+    errCode = NtQueryVolumeInformationFile(hFile,
+                                           &IoStatusBlock,
+                                           FileFsVolume,
+                                           FS_VOLUME_BUFFER_SIZE,
+                                           FileFsVolumeInformation);
+    if ( !NT_SUCCESS(errCode) )
+    {
+        WARN("Status: %x\n", errCode);
+        CloseHandle(hFile);
+        SetLastErrorByStatus (errCode);
+        return FALSE;
+    }
+
+    if (lpVolumeSerialNumber)
+        *lpVolumeSerialNumber = FileFsVolume->VolumeSerialNumber;
+
+    if (lpVolumeNameBuffer)
+    {
+        if (nVolumeNameSize * sizeof(WCHAR) >= FileFsVolume->VolumeLabelLength +
sizeof(WCHAR))
+        {
+            memcpy(lpVolumeNameBuffer,
+                   FileFsVolume->VolumeLabel,
+                   FileFsVolume->VolumeLabelLength);
+            lpVolumeNameBuffer[FileFsVolume->VolumeLabelLength / sizeof(WCHAR)] = 0;
+        }
+        else
+        {
+            CloseHandle(hFile);
+            SetLastError(ERROR_MORE_DATA);
+            return FALSE;
+        }
+    }
+
+    errCode = NtQueryVolumeInformationFile (hFile,
+                                            &IoStatusBlock,
+                                            FileFsAttribute,
+                                            FS_ATTRIBUTE_BUFFER_SIZE,
+                                            FileFsAttributeInformation);
+    CloseHandle(hFile);
+    if (!NT_SUCCESS(errCode))
+    {
+        WARN("Status: %x\n", errCode);
+        SetLastErrorByStatus (errCode);
+        return FALSE;
+    }
+
+    if (lpFileSystemFlags)
+        *lpFileSystemFlags = FileFsAttribute->FileSystemAttributes;
+    if (lpMaximumComponentLength)
+        *lpMaximumComponentLength = FileFsAttribute->MaximumComponentNameLength;
+    if (lpFileSystemNameBuffer)
+    {
+        if (nFileSystemNameSize * sizeof(WCHAR) >=
FileFsAttribute->FileSystemNameLength + sizeof(WCHAR))
+        {
+            memcpy(lpFileSystemNameBuffer,
+                   FileFsAttribute->FileSystemName,
+                   FileFsAttribute->FileSystemNameLength);
+            lpFileSystemNameBuffer[FileFsAttribute->FileSystemNameLength /
sizeof(WCHAR)] = 0;
+        }
+        else
+        {
+            SetLastError(ERROR_MORE_DATA);
+            return FALSE;
+        }
+    }
+    return TRUE;
 }
 
 
@@ -795,34 +795,34 @@
 BOOL
 WINAPI
 SetVolumeLabelA (
-	LPCSTR	lpRootPathName,
-	LPCSTR	lpVolumeName /* NULL if deleting label */
-	)
-{
-	PWCHAR RootPathNameW;
-   PWCHAR VolumeNameW = NULL;
-	BOOL Result;
-
-   if (!(RootPathNameW = FilenameA2W(lpRootPathName, FALSE)))
-      return FALSE;
-
-   if (lpVolumeName)
-   {
-      if (!(VolumeNameW = FilenameA2W(lpVolumeName, TRUE)))
-         return FALSE;
-   }
-
-   Result = SetVolumeLabelW (RootPathNameW,
-                             VolumeNameW);
-
-   if (VolumeNameW)
-   {
-	   RtlFreeHeap (RtlGetProcessHeap (),
-	                0,
-                   VolumeNameW );
-   }
-
-	return Result;
+    LPCSTR	lpRootPathName,
+    LPCSTR	lpVolumeName /* NULL if deleting label */
+)
+{
+    PWCHAR RootPathNameW;
+    PWCHAR VolumeNameW = NULL;
+    BOOL Result;
+
+    if (!(RootPathNameW = FilenameA2W(lpRootPathName, FALSE)))
+        return FALSE;
+
+    if (lpVolumeName)
+    {
+        if (!(VolumeNameW = FilenameA2W(lpVolumeName, TRUE)))
+            return FALSE;
+    }
+
+    Result = SetVolumeLabelW (RootPathNameW,
+                              VolumeNameW);
+
+    if (VolumeNameW)
+    {
+        RtlFreeHeap (RtlGetProcessHeap (),
+                     0,
+                     VolumeNameW );
+    }
+
+    return Result;
 }
 
 
@@ -831,61 +831,61 @@
  */
 BOOL WINAPI
 SetVolumeLabelW(
-   LPCWSTR lpRootPathName,
-   LPCWSTR lpVolumeName /* NULL if deleting label */
-   )
-{
-   PFILE_FS_LABEL_INFORMATION LabelInfo;
-   IO_STATUS_BLOCK IoStatusBlock;
-   ULONG LabelLength;
-   HANDLE hFile;
-   NTSTATUS Status;
-
-   LabelLength = wcslen(lpVolumeName) * sizeof(WCHAR);
-   LabelInfo = RtlAllocateHeap(RtlGetProcessHeap(),
-			       0,
-			       sizeof(FILE_FS_LABEL_INFORMATION) +
-			       LabelLength);
-   if (LabelInfo == NULL)
-   {
-       SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-       return FALSE;
-   }
-   LabelInfo->VolumeLabelLength = LabelLength;
-   memcpy(LabelInfo->VolumeLabel,
-	  lpVolumeName,
-	  LabelLength);
-
-   hFile = InternalOpenDirW(lpRootPathName, TRUE);
-   if (INVALID_HANDLE_VALUE == hFile)
-   {
+    LPCWSTR lpRootPathName,
+    LPCWSTR lpVolumeName /* NULL if deleting label */
+)
+{
+    PFILE_FS_LABEL_INFORMATION LabelInfo;
+    IO_STATUS_BLOCK IoStatusBlock;
+    ULONG LabelLength;
+    HANDLE hFile;
+    NTSTATUS Status;
+
+    LabelLength = wcslen(lpVolumeName) * sizeof(WCHAR);
+    LabelInfo = RtlAllocateHeap(RtlGetProcessHeap(),
+                                0,
+                                sizeof(FILE_FS_LABEL_INFORMATION) +
+                                LabelLength);
+    if (LabelInfo == NULL)
+    {
+        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+        return FALSE;
+    }
+    LabelInfo->VolumeLabelLength = LabelLength;
+    memcpy(LabelInfo->VolumeLabel,
+           lpVolumeName,
+           LabelLength);
+
+    hFile = InternalOpenDirW(lpRootPathName, TRUE);
+    if (INVALID_HANDLE_VALUE == hFile)
+    {
         RtlFreeHeap(RtlGetProcessHeap(),
-	            0,
-	            LabelInfo);
-        return FALSE;
-   }
-
-   Status = NtSetVolumeInformationFile(hFile,
-				       &IoStatusBlock,
-				       LabelInfo,
-				       sizeof(FILE_FS_LABEL_INFORMATION) +
-				       LabelLength,
-				       FileFsLabelInformation);
-
-   RtlFreeHeap(RtlGetProcessHeap(),
-	       0,
-	       LabelInfo);
-
-   if (!NT_SUCCESS(Status))
-     {
-	WARN("Status: %x\n", Status);
-	CloseHandle(hFile);
-	SetLastErrorByStatus(Status);
-	return FALSE;
-     }
-
-   CloseHandle(hFile);
-   return TRUE;
+                    0,
+                    LabelInfo);
+        return FALSE;
+    }
+
+    Status = NtSetVolumeInformationFile(hFile,
+                                        &IoStatusBlock,
+                                        LabelInfo,
+                                        sizeof(FILE_FS_LABEL_INFORMATION) +
+                                        LabelLength,
+                                        FileFsLabelInformation);
+
+    RtlFreeHeap(RtlGetProcessHeap(),
+                0,
+                LabelInfo);
+
+    if (!NT_SUCCESS(Status))
+    {
+        WARN("Status: %x\n", Status);
+        CloseHandle(hFile);
+        SetLastErrorByStatus(Status);
+        return FALSE;
+    }
+
+    CloseHandle(hFile);
+    return TRUE;
 }
 
 /**
@@ -909,217 +909,217 @@
 
 BOOL WINAPI
 GetVolumeNameForVolumeMountPointW(
-   IN LPCWSTR VolumeMountPoint,
-   OUT LPWSTR VolumeName,
-   IN DWORD VolumeNameLength)
-{
-   UNICODE_STRING NtFileName;
-   OBJECT_ATTRIBUTES ObjectAttributes;
-   HANDLE FileHandle;
-   IO_STATUS_BLOCK Iosb;
-   ULONG BufferLength;
-   PMOUNTDEV_NAME MountDevName;
-   PMOUNTMGR_MOUNT_POINT MountPoint;
-   ULONG MountPointSize;
-   PMOUNTMGR_MOUNT_POINTS MountPoints;
-   ULONG Index;
-   PUCHAR SymbolicLinkName;
-   BOOL Result;
-   NTSTATUS Status;
-
-   if (!VolumeMountPoint || !VolumeMountPoint[0])
-   {
-       SetLastError(ERROR_PATH_NOT_FOUND);
-       return FALSE;
-   }
-
-   /*
-    * First step is to convert the passed volume mount point name to
-    * an NT acceptable name.
-    */
-
-   if (!RtlDosPathNameToNtPathName_U(VolumeMountPoint, &NtFileName, NULL, NULL))
-   {
-      SetLastError(ERROR_PATH_NOT_FOUND);
-      return FALSE;
-   }
-
-   if (NtFileName.Length > sizeof(WCHAR) &&
-       NtFileName.Buffer[(NtFileName.Length / sizeof(WCHAR)) - 1] == '\\')
-   {
-      NtFileName.Length -= sizeof(WCHAR);
-   }
-
-   /*
-    * Query mount point device name which we will later use for determining
-    * the volume name.
-    */
-
-   InitializeObjectAttributes(&ObjectAttributes, &NtFileName, 0, NULL, NULL);
-   Status = NtOpenFile(&FileHandle, FILE_READ_ATTRIBUTES | SYNCHRONIZE,
-                       &ObjectAttributes, &Iosb,
-                       FILE_SHARE_READ | FILE_SHARE_WRITE,
-                       FILE_SYNCHRONOUS_IO_NONALERT);
-   RtlFreeUnicodeString(&NtFileName);
-   if (!NT_SUCCESS(Status))
-   {
-      SetLastErrorByStatus(Status);
-      return FALSE;
-   }
-
-   BufferLength = sizeof(MOUNTDEV_NAME) + 50 * sizeof(WCHAR);
-   do
-   {
-      MountDevName = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
-      if (MountDevName == NULL)
-      {
-         NtClose(FileHandle);
-         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-         return FALSE;
-      }
-
-      Status = NtDeviceIoControlFile(FileHandle, NULL, NULL, NULL, &Iosb,
-                                     IOCTL_MOUNTDEV_QUERY_DEVICE_NAME,
-                                     NULL, 0, MountDevName, BufferLength);
-      if (!NT_SUCCESS(Status))
-      {
-         RtlFreeHeap(GetProcessHeap(), 0, MountDevName);
-         if (Status == STATUS_BUFFER_OVERFLOW)
-         {
-            BufferLength = sizeof(MOUNTDEV_NAME) + MountDevName->NameLength;
-            continue;
-         }
-         else
-         {
+    IN LPCWSTR VolumeMountPoint,
+    OUT LPWSTR VolumeName,
+    IN DWORD VolumeNameLength)
+{
+    UNICODE_STRING NtFileName;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    HANDLE FileHandle;
+    IO_STATUS_BLOCK Iosb;
+    ULONG BufferLength;
+    PMOUNTDEV_NAME MountDevName;
+    PMOUNTMGR_MOUNT_POINT MountPoint;
+    ULONG MountPointSize;
+    PMOUNTMGR_MOUNT_POINTS MountPoints;
+    ULONG Index;
+    PUCHAR SymbolicLinkName;
+    BOOL Result;
+    NTSTATUS Status;
+
+    if (!VolumeMountPoint || !VolumeMountPoint[0])
+    {
+        SetLastError(ERROR_PATH_NOT_FOUND);
+        return FALSE;
+    }
+
+    /*
+     * First step is to convert the passed volume mount point name to
+     * an NT acceptable name.
+     */
+
+    if (!RtlDosPathNameToNtPathName_U(VolumeMountPoint, &NtFileName, NULL, NULL))
+    {
+        SetLastError(ERROR_PATH_NOT_FOUND);
+        return FALSE;
+    }
+
+    if (NtFileName.Length > sizeof(WCHAR) &&
+            NtFileName.Buffer[(NtFileName.Length / sizeof(WCHAR)) - 1] == '\\')
+    {
+        NtFileName.Length -= sizeof(WCHAR);
+    }
+
+    /*
+     * Query mount point device name which we will later use for determining
+     * the volume name.
+     */
+
+    InitializeObjectAttributes(&ObjectAttributes, &NtFileName, 0, NULL, NULL);
+    Status = NtOpenFile(&FileHandle, FILE_READ_ATTRIBUTES | SYNCHRONIZE,
+                        &ObjectAttributes, &Iosb,
+                        FILE_SHARE_READ | FILE_SHARE_WRITE,
+                        FILE_SYNCHRONOUS_IO_NONALERT);
+    RtlFreeUnicodeString(&NtFileName);
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastErrorByStatus(Status);
+        return FALSE;
+    }
+
+    BufferLength = sizeof(MOUNTDEV_NAME) + 50 * sizeof(WCHAR);
+    do
+    {
+        MountDevName = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
+        if (MountDevName == NULL)
+        {
             NtClose(FileHandle);
-            SetLastErrorByStatus(Status);
+            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
             return FALSE;
-         }
-      }
-   }
-   while (!NT_SUCCESS(Status));
-
-   NtClose(FileHandle);
-
-   /*
-    * Get the mount point information from mount manager.
-    */
-
-   MountPointSize = MountDevName->NameLength + sizeof(MOUNTMGR_MOUNT_POINT);
-   MountPoint = RtlAllocateHeap(GetProcessHeap(), 0, MountPointSize);
-   if (MountPoint == NULL)
-   {
-      RtlFreeHeap(GetProcessHeap(), 0, MountDevName);
-      SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-      return FALSE;
-   }
-   RtlZeroMemory(MountPoint, sizeof(MOUNTMGR_MOUNT_POINT));
-   MountPoint->DeviceNameOffset = sizeof(MOUNTMGR_MOUNT_POINT);
-   MountPoint->DeviceNameLength = MountDevName->NameLength;
-   RtlCopyMemory(MountPoint + 1, MountDevName->Name, MountDevName->NameLength);
-   RtlFreeHeap(RtlGetProcessHeap(), 0, MountDevName);
-
-   RtlInitUnicodeString(&NtFileName, L"\\??\\MountPointManager");
-   InitializeObjectAttributes(&ObjectAttributes, &NtFileName, 0, NULL, NULL);
-   Status = NtOpenFile(&FileHandle, FILE_GENERIC_READ | SYNCHRONIZE,
&ObjectAttributes,
-                       &Iosb, FILE_SHARE_READ | FILE_SHARE_WRITE,
-                       FILE_SYNCHRONOUS_IO_NONALERT);
-   if (!NT_SUCCESS(Status))
-   {
-      SetLastErrorByStatus(Status);
-      RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoint);
-      return FALSE;
-   }
-
-   BufferLength = sizeof(MOUNTMGR_MOUNT_POINTS);
-   do
-   {
-      MountPoints = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
-      if (MountPoints == NULL)
-      {
-         RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoint);
-         NtClose(FileHandle);
-         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-         return FALSE;
-      }
-
-      Status = NtDeviceIoControlFile(FileHandle, NULL, NULL, NULL, &Iosb,
-                                     IOCTL_MOUNTMGR_QUERY_POINTS,
-                                     MountPoint, MountPointSize,
-                                     MountPoints, BufferLength);
-      if (!NT_SUCCESS(Status))
-      {
-         if (Status == STATUS_BUFFER_OVERFLOW)
-         {
-            BufferLength = MountPoints->Size;
-            RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints);
-            continue;
-         }
-         else if (!NT_SUCCESS(Status))
-         {
+        }
+
+        Status = NtDeviceIoControlFile(FileHandle, NULL, NULL, NULL, &Iosb,
+                                       IOCTL_MOUNTDEV_QUERY_DEVICE_NAME,
+                                       NULL, 0, MountDevName, BufferLength);
+        if (!NT_SUCCESS(Status))
+        {
+            RtlFreeHeap(GetProcessHeap(), 0, MountDevName);
+            if (Status == STATUS_BUFFER_OVERFLOW)
+            {
+                BufferLength = sizeof(MOUNTDEV_NAME) + MountDevName->NameLength;
+                continue;
+            }
+            else
+            {
+                NtClose(FileHandle);
+                SetLastErrorByStatus(Status);
+                return FALSE;
+            }
+        }
+    }
+    while (!NT_SUCCESS(Status));
+
+    NtClose(FileHandle);
+
+    /*
+     * Get the mount point information from mount manager.
+     */
+
+    MountPointSize = MountDevName->NameLength + sizeof(MOUNTMGR_MOUNT_POINT);
+    MountPoint = RtlAllocateHeap(GetProcessHeap(), 0, MountPointSize);
+    if (MountPoint == NULL)
+    {
+        RtlFreeHeap(GetProcessHeap(), 0, MountDevName);
+        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+        return FALSE;
+    }
+    RtlZeroMemory(MountPoint, sizeof(MOUNTMGR_MOUNT_POINT));
+    MountPoint->DeviceNameOffset = sizeof(MOUNTMGR_MOUNT_POINT);
+    MountPoint->DeviceNameLength = MountDevName->NameLength;
+    RtlCopyMemory(MountPoint + 1, MountDevName->Name, MountDevName->NameLength);
+    RtlFreeHeap(RtlGetProcessHeap(), 0, MountDevName);
+
+    RtlInitUnicodeString(&NtFileName, L"\\??\\MountPointManager");
+    InitializeObjectAttributes(&ObjectAttributes, &NtFileName, 0, NULL, NULL);
+    Status = NtOpenFile(&FileHandle, FILE_GENERIC_READ | SYNCHRONIZE,
&ObjectAttributes,
+                        &Iosb, FILE_SHARE_READ | FILE_SHARE_WRITE,
+                        FILE_SYNCHRONOUS_IO_NONALERT);
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastErrorByStatus(Status);
+        RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoint);
+        return FALSE;
+    }
+
+    BufferLength = sizeof(MOUNTMGR_MOUNT_POINTS);
+    do
+    {
+        MountPoints = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
+        if (MountPoints == NULL)
+        {
             RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoint);
-            RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints);
             NtClose(FileHandle);
-            SetLastErrorByStatus(Status);
+            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
             return FALSE;
-         }
-      }
-   }
-   while (!NT_SUCCESS(Status));
-
-   RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoint);
-   NtClose(FileHandle);
-
-   /*
-    * Now we've gathered info about all mount points mapped to our device, so
-    * select the correct one and copy it into the output buffer.
-    */
-
-   for (Index = 0; Index < MountPoints->NumberOfMountPoints; Index++)
-   {
-      MountPoint = MountPoints->MountPoints + Index;
-      SymbolicLinkName = (PUCHAR)MountPoints + MountPoint->SymbolicLinkNameOffset;
-
-      /*
-       * Check for "\\?\Volume{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}\"
-       * (with the last slash being optional) style symbolic links.
-       */
-
-      if (MountPoint->SymbolicLinkNameLength == 48 * sizeof(WCHAR) ||
-          (MountPoint->SymbolicLinkNameLength == 49 * sizeof(WCHAR) &&
-           SymbolicLinkName[48] == L'\\'))
-      {
-         if (RtlCompareMemory(SymbolicLinkName, L"\\??\\Volume{",
-                              11 * sizeof(WCHAR)) == 11 * sizeof(WCHAR) &&
-             SymbolicLinkName[19] == L'-' && SymbolicLinkName[24] ==
L'-' &&
-             SymbolicLinkName[29] == L'-' && SymbolicLinkName[34] ==
L'-' &&
-             SymbolicLinkName[47] == L'}')
-         {
-            if (VolumeNameLength >= MountPoint->SymbolicLinkNameLength /
sizeof(WCHAR))
-            {
-               RtlCopyMemory(VolumeName,
-                             (PUCHAR)MountPoints +
MountPoint->SymbolicLinkNameOffset,
-                             MountPoint->SymbolicLinkNameLength);
-               VolumeName[1] = L'\\';
-               Result = TRUE;
-            }
-            else
-            {
-               SetLastError(ERROR_FILENAME_EXCED_RANGE);
-               Result = FALSE;
-            }
-
-            RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints);
-
-            return Result;
-         }
-      }
-   }
-
-   RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints);
-   SetLastError(ERROR_INVALID_PARAMETER);
-
-   return FALSE;
+        }
+
+        Status = NtDeviceIoControlFile(FileHandle, NULL, NULL, NULL, &Iosb,
+                                       IOCTL_MOUNTMGR_QUERY_POINTS,
+                                       MountPoint, MountPointSize,
+                                       MountPoints, BufferLength);
+        if (!NT_SUCCESS(Status))
+        {
+            if (Status == STATUS_BUFFER_OVERFLOW)
+            {
+                BufferLength = MountPoints->Size;
+                RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints);
+                continue;
+            }
+            else if (!NT_SUCCESS(Status))
+            {
+                RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoint);
+                RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints);
+                NtClose(FileHandle);
+                SetLastErrorByStatus(Status);
+                return FALSE;
+            }
+        }
+    }
+    while (!NT_SUCCESS(Status));
+
+    RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoint);
+    NtClose(FileHandle);
+
+    /*
+     * Now we've gathered info about all mount points mapped to our device, so
+     * select the correct one and copy it into the output buffer.
+     */
+
+    for (Index = 0; Index < MountPoints->NumberOfMountPoints; Index++)
+    {
+        MountPoint = MountPoints->MountPoints + Index;
+        SymbolicLinkName = (PUCHAR)MountPoints + MountPoint->SymbolicLinkNameOffset;
+
+        /*
+         * Check for "\\?\Volume{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}\"
+         * (with the last slash being optional) style symbolic links.
+         */
+
+        if (MountPoint->SymbolicLinkNameLength == 48 * sizeof(WCHAR) ||
+                (MountPoint->SymbolicLinkNameLength == 49 * sizeof(WCHAR) &&
+                 SymbolicLinkName[48] == L'\\'))
+        {
+            if (RtlCompareMemory(SymbolicLinkName, L"\\??\\Volume{",
+                                 11 * sizeof(WCHAR)) == 11 * sizeof(WCHAR) &&
+                    SymbolicLinkName[19] == L'-' && SymbolicLinkName[24]
== L'-' &&
+                    SymbolicLinkName[29] == L'-' && SymbolicLinkName[34]
== L'-' &&
+                    SymbolicLinkName[47] == L'}')
+            {
+                if (VolumeNameLength >= MountPoint->SymbolicLinkNameLength /
sizeof(WCHAR))
+                {
+                    RtlCopyMemory(VolumeName,
+                                  (PUCHAR)MountPoints +
MountPoint->SymbolicLinkNameOffset,
+                                  MountPoint->SymbolicLinkNameLength);
+                    VolumeName[1] = L'\\';
+                    Result = TRUE;
+                }
+                else
+                {
+                    SetLastError(ERROR_FILENAME_EXCED_RANGE);
+                    Result = FALSE;
+                }
+
+                RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints);
+
+                return Result;
+            }
+        }
+    }
+
+    RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints);
+    SetLastError(ERROR_INVALID_PARAMETER);
+
+    return FALSE;
 }
 
 /*
@@ -1131,7 +1131,7 @@
     LPCSTR lpszVolumeMountPoint,
     LPSTR lpszVolumeName,
     DWORD cchBufferLength
-    )
+)
 {
     BOOL ret;
     WCHAR volumeW[50], *pathW = NULL;
@@ -1155,9 +1155,9 @@
 HANDLE
 WINAPI
 FindFirstVolumeW(
-	LPWSTR volume,
-	DWORD len
-    )
+    LPWSTR volume,
+    DWORD len
+)
 {
     DWORD size = 1024;
     HANDLE mgr = CreateFileW( MOUNTMGR_DOS_DEVICE_NAME, 0,
FILE_SHARE_READ|FILE_SHARE_WRITE,
@@ -1204,9 +1204,9 @@
 HANDLE
 WINAPI
 FindFirstVolumeA(
-	LPSTR volume,
-	DWORD len
-    )
+    LPSTR volume,
+    DWORD len
+)
 {
     WCHAR *buffer = NULL;
     HANDLE handle;
@@ -1240,7 +1240,7 @@
 WINAPI
 FindVolumeClose(
     HANDLE hFindVolume
-    )
+)
 {
     return RtlFreeHeap(RtlGetProcessHeap(), 0, hFindVolume);
 }
@@ -1328,12 +1328,12 @@
         }
 
         while (!GetVolumeNameForVolumeMountPointW(UnicodeFilePath.Buffer,
-                                                  VolumeName,
-                                                  MAX_PATH))
+                VolumeName,
+                MAX_PATH))
         {
             if (((UnicodeFilePath.Length == 4) && (UnicodeFilePath.Buffer[0] ==
'\\') &&
-                (UnicodeFilePath.Buffer[1] == '\\')) || ((UnicodeFilePath.Length
== 6) &&
-                (UnicodeFilePath.Buffer[1] == ':')))
+                    (UnicodeFilePath.Buffer[1] == '\\')) ||
((UnicodeFilePath.Length == 6) &&
+                            (UnicodeFilePath.Buffer[1] == ':')))
             {
                 break;
             }