[akhaldi] 57246: [FORMATTING] * No code changes.

Author: akhaldi
Date: Thu Sep  6 18:36:48 2012
New Revision: 57246

URL: http://svn.reactos.org/svn/reactos?rev=57246&view=rev
Log:
[FORMATTING]
* No code changes.

Modified:
    trunk/reactos/drivers/filesystems/fastfat/dir.c

Modified: trunk/reactos/drivers/filesystems/fastfat/dir.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa…
==============================================================================
--- trunk/reactos/drivers/filesystems/fastfat/dir.c [iso-8859-1] (original)
+++ trunk/reactos/drivers/filesystems/fastfat/dir.c [iso-8859-1] Thu Sep  6 18:36:48 2012
@@ -8,504 +8,602 @@
 
 */
 
+/* INCLUDES *****************************************************************/
+
 #define NDEBUG
 #include "vfat.h"
 
-
-// function like DosDateTimeToFileTime
+/* FUNCTIONS ****************************************************************/
+
+/* Function like DosDateTimeToFileTime */
 BOOLEAN
-FsdDosDateTimeToSystemTime (PDEVICE_EXTENSION DeviceExt, USHORT DosDate, USHORT DosTime,
PLARGE_INTEGER SystemTime)
-{
-  PDOSTIME pdtime = (PDOSTIME) &DosTime;
-  PDOSDATE pddate = (PDOSDATE) &DosDate;
-  TIME_FIELDS TimeFields;
-  LARGE_INTEGER LocalTime;
-
-  if (SystemTime == NULL)
-    return FALSE;
-
-  TimeFields.Milliseconds = 0;
-  TimeFields.Second = pdtime->Second * 2;
-  TimeFields.Minute = pdtime->Minute;
-  TimeFields.Hour = pdtime->Hour;
-
-  TimeFields.Day = pddate->Day;
-  TimeFields.Month = pddate->Month;
-  TimeFields.Year = (CSHORT)(DeviceExt->BaseDateYear + pddate->Year);
-
-  RtlTimeFieldsToTime (&TimeFields, &LocalTime);
-  ExLocalTimeToSystemTime(&LocalTime, SystemTime);
-
-  return TRUE;
-}
-
-// function like FileTimeToDosDateTime
+FsdDosDateTimeToSystemTime(PDEVICE_EXTENSION DeviceExt,
+                           USHORT DosDate,
+                           USHORT DosTime,
+                           PLARGE_INTEGER SystemTime)
+{
+    PDOSTIME pdtime = (PDOSTIME)&DosTime;
+    PDOSDATE pddate = (PDOSDATE)&DosDate;
+    TIME_FIELDS TimeFields;
+    LARGE_INTEGER LocalTime;
+
+    if (SystemTime == NULL)
+        return FALSE;
+
+    TimeFields.Milliseconds = 0;
+    TimeFields.Second = pdtime->Second * 2;
+    TimeFields.Minute = pdtime->Minute;
+    TimeFields.Hour = pdtime->Hour;
+
+    TimeFields.Day = pddate->Day;
+    TimeFields.Month = pddate->Month;
+    TimeFields.Year = (CSHORT)(DeviceExt->BaseDateYear + pddate->Year);
+
+    RtlTimeFieldsToTime(&TimeFields, &LocalTime);
+    ExLocalTimeToSystemTime(&LocalTime, SystemTime);
+
+    return TRUE;
+}
+
+/* Function like FileTimeToDosDateTime */
 BOOLEAN
-FsdSystemTimeToDosDateTime (PDEVICE_EXTENSION DeviceExt, PLARGE_INTEGER SystemTime,
USHORT *pDosDate, USHORT *pDosTime)
-{
-  PDOSTIME pdtime = (PDOSTIME) pDosTime;
-  PDOSDATE pddate = (PDOSDATE) pDosDate;
-  TIME_FIELDS TimeFields;
-  LARGE_INTEGER LocalTime;
-
-  if (SystemTime == NULL)
-    return FALSE;
-
-  ExSystemTimeToLocalTime (SystemTime, &LocalTime);
-  RtlTimeToTimeFields (&LocalTime, &TimeFields);
-
-  if (pdtime)
-    {
-      pdtime->Second = TimeFields.Second / 2;
-      pdtime->Minute = TimeFields.Minute;
-      pdtime->Hour = TimeFields.Hour;
-    }
-
-  if (pddate)
-    {
-      pddate->Day = TimeFields.Day;
-      pddate->Month = TimeFields.Month;
-      pddate->Year = (USHORT) (TimeFields.Year - DeviceExt->BaseDateYear);
-    }
-
-  return TRUE;
+FsdSystemTimeToDosDateTime(PDEVICE_EXTENSION DeviceExt,
+                           PLARGE_INTEGER SystemTime,
+                           PUSHORT pDosDate,
+                           PUSHORT pDosTime)
+{
+    PDOSTIME pdtime = (PDOSTIME)pDosTime;
+    PDOSDATE pddate = (PDOSDATE)pDosDate;
+    TIME_FIELDS TimeFields;
+    LARGE_INTEGER LocalTime;
+
+    if (SystemTime == NULL)
+        return FALSE;
+
+    ExSystemTimeToLocalTime(SystemTime, &LocalTime);
+    RtlTimeToTimeFields(&LocalTime, &TimeFields);
+
+    if (pdtime)
+    {
+        pdtime->Second = TimeFields.Second / 2;
+        pdtime->Minute = TimeFields.Minute;
+        pdtime->Hour = TimeFields.Hour;
+    }
+
+    if (pddate)
+    {
+        pddate->Day = TimeFields.Day;
+        pddate->Month = TimeFields.Month;
+        pddate->Year = (USHORT) (TimeFields.Year - DeviceExt->BaseDateYear);
+    }
+
+    return TRUE;
 }
 
 #define ULONG_ROUND_UP(x)   ROUND_UP((x), (sizeof(ULONG)))
 
 static NTSTATUS
-VfatGetFileNameInformation (PVFAT_DIRENTRY_CONTEXT DirContext,
-			    PFILE_NAMES_INFORMATION pInfo, ULONG BufferLength)
-{
-  if ((sizeof (FILE_DIRECTORY_INFORMATION) + DirContext->LongNameU.Length) >
BufferLength)
-    return STATUS_BUFFER_OVERFLOW;
-  pInfo->FileNameLength = DirContext->LongNameU.Length;
-  pInfo->NextEntryOffset =
-    ULONG_ROUND_UP (sizeof (FILE_DIRECTORY_INFORMATION) +
DirContext->LongNameU.Length);
-  RtlCopyMemory (pInfo->FileName, DirContext->LongNameU.Buffer,
DirContext->LongNameU.Length);
-  return STATUS_SUCCESS;
+VfatGetFileNameInformation(PVFAT_DIRENTRY_CONTEXT DirContext,
+                           PFILE_NAMES_INFORMATION pInfo,
+                           ULONG BufferLength)
+{
+    if ((sizeof(FILE_DIRECTORY_INFORMATION) + DirContext->LongNameU.Length) >
BufferLength)
+        return STATUS_BUFFER_OVERFLOW;
+
+    pInfo->FileNameLength = DirContext->LongNameU.Length;
+    pInfo->NextEntryOffset = ULONG_ROUND_UP(sizeof(FILE_DIRECTORY_INFORMATION) +
+                                            DirContext->LongNameU.Length);
+
+    RtlCopyMemory(pInfo->FileName,
+                  DirContext->LongNameU.Buffer,
+                  DirContext->LongNameU.Length);
+
+    return STATUS_SUCCESS;
 }
 
 static NTSTATUS
-VfatGetFileDirectoryInformation (PVFAT_DIRENTRY_CONTEXT DirContext,
-				 PDEVICE_EXTENSION DeviceExt,
-				 PFILE_DIRECTORY_INFORMATION pInfo,
-				 ULONG BufferLength)
-{
-  if ((sizeof (FILE_DIRECTORY_INFORMATION) + DirContext->LongNameU.Length) >
BufferLength)
-    return STATUS_BUFFER_OVERFLOW;
-  pInfo->FileNameLength = DirContext->LongNameU.Length;
-  pInfo->NextEntryOffset =
-    ULONG_ROUND_UP (sizeof (FILE_DIRECTORY_INFORMATION) +
DirContext->LongNameU.Length);
-  RtlCopyMemory (pInfo->FileName, DirContext->LongNameU.Buffer,
DirContext->LongNameU.Length);
-//      pInfo->FileIndex=;
-  if (DeviceExt->Flags & VCB_IS_FATX)
-  {
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.FatX.CreationDate,
-			      DirContext->DirEntry.FatX.CreationTime,
-			      &pInfo->CreationTime);
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.FatX.AccessDate,
-               DirContext->DirEntry.FatX.AccessTime,
-			      &pInfo->LastAccessTime);
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.FatX.UpdateDate,
-			      DirContext->DirEntry.FatX.UpdateTime,
-			      &pInfo->LastWriteTime);
-    pInfo->ChangeTime = pInfo->LastWriteTime;
-    if (DirContext->DirEntry.FatX.Attrib & FILE_ATTRIBUTE_DIRECTORY)
-      {
-        pInfo->EndOfFile.QuadPart = 0;
-        pInfo->AllocationSize.QuadPart = 0;
-      }
+VfatGetFileDirectoryInformation(PVFAT_DIRENTRY_CONTEXT DirContext,
+                                PDEVICE_EXTENSION DeviceExt,
+                                PFILE_DIRECTORY_INFORMATION pInfo,
+                                ULONG BufferLength)
+{
+    if ((sizeof(FILE_DIRECTORY_INFORMATION) + DirContext->LongNameU.Length) >
BufferLength)
+        return STATUS_BUFFER_OVERFLOW;
+
+    pInfo->FileNameLength = DirContext->LongNameU.Length;
+    pInfo->NextEntryOffset = ULONG_ROUND_UP(sizeof(FILE_DIRECTORY_INFORMATION) +
+                                            DirContext->LongNameU.Length);
+    /* pInfo->FileIndex = ; */
+
+    RtlCopyMemory(pInfo->FileName,
+                  DirContext->LongNameU.Buffer,
+                  DirContext->LongNameU.Length);
+
+    if (DeviceExt->Flags & VCB_IS_FATX)
+    {
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.FatX.CreationDate,
+                                   DirContext->DirEntry.FatX.CreationTime,
+                                   &pInfo->CreationTime);
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.FatX.AccessDate,
+                                   DirContext->DirEntry.FatX.AccessTime,
+                                   &pInfo->LastAccessTime);
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.FatX.UpdateDate,
+                                   DirContext->DirEntry.FatX.UpdateTime,
+                                   &pInfo->LastWriteTime);
+
+        pInfo->ChangeTime = pInfo->LastWriteTime;
+
+        if (DirContext->DirEntry.FatX.Attrib & FILE_ATTRIBUTE_DIRECTORY)
+        {
+            pInfo->EndOfFile.QuadPart = 0;
+            pInfo->AllocationSize.QuadPart = 0;
+        }
+        else
+        {
+            pInfo->EndOfFile.u.HighPart = 0;
+            pInfo->EndOfFile.u.LowPart = DirContext->DirEntry.FatX.FileSize;
+            /* Make allocsize a rounded up multiple of BytesPerCluster */
+            pInfo->AllocationSize.u.HighPart = 0;
+            pInfo->AllocationSize.u.LowPart =
ROUND_UP(DirContext->DirEntry.FatX.FileSize,
+                                                      
DeviceExt->FatInfo.BytesPerCluster);
+        }
+    
+        pInfo->FileAttributes = DirContext->DirEntry.FatX.Attrib & 0x3f;
+    }
     else
-      {
+    {
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.Fat.CreationDate,
+                                   DirContext->DirEntry.Fat.CreationTime,
+                                   &pInfo->CreationTime);
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.Fat.AccessDate,
+                                   0,
+                                   &pInfo->LastAccessTime);
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.Fat.UpdateDate,
+                                   DirContext->DirEntry.Fat.UpdateTime,
+                                   &pInfo->LastWriteTime);
+
+        pInfo->ChangeTime = pInfo->LastWriteTime;
+
+        if (DirContext->DirEntry.Fat.Attrib & FILE_ATTRIBUTE_DIRECTORY)
+        {
+            pInfo->EndOfFile.QuadPart = 0;
+            pInfo->AllocationSize.QuadPart = 0;
+        }
+        else
+        {
+            pInfo->EndOfFile.u.HighPart = 0;
+            pInfo->EndOfFile.u.LowPart = DirContext->DirEntry.Fat.FileSize;
+            /* Make allocsize a rounded up multiple of BytesPerCluster */
+            pInfo->AllocationSize.u.HighPart = 0;
+            pInfo->AllocationSize.u.LowPart =
ROUND_UP(DirContext->DirEntry.Fat.FileSize,
+                                                      
DeviceExt->FatInfo.BytesPerCluster);
+        }
+
+        pInfo->FileAttributes = DirContext->DirEntry.Fat.Attrib & 0x3f;
+    }
+
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS
+VfatGetFileFullDirectoryInformation(PVFAT_DIRENTRY_CONTEXT DirContext,
+                                    PDEVICE_EXTENSION DeviceExt,
+                                    PFILE_FULL_DIR_INFORMATION pInfo,
+                                    ULONG BufferLength)
+{
+    if ((sizeof(FILE_FULL_DIR_INFORMATION) + DirContext->LongNameU.Length) >
BufferLength)
+        return STATUS_BUFFER_OVERFLOW;
+
+    pInfo->FileNameLength = DirContext->LongNameU.Length;
+    pInfo->NextEntryOffset = ULONG_ROUND_UP(sizeof(FILE_FULL_DIR_INFORMATION) +
+                                            DirContext->LongNameU.Length);
+    /* pInfo->FileIndex = ; */
+    /* pInfo->EaSize = ; */
+
+    RtlCopyMemory(pInfo->FileName,
+                  DirContext->LongNameU.Buffer,
+                  DirContext->LongNameU.Length);
+
+    if (DeviceExt->Flags & VCB_IS_FATX)
+    {
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.FatX.CreationDate,
+                                   DirContext->DirEntry.FatX.CreationTime,
+                                   &pInfo->CreationTime);
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.FatX.AccessDate,
+                                   DirContext->DirEntry.FatX.AccessTime,
+                                   &pInfo->LastAccessTime);
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.FatX.UpdateDate,
+                                   DirContext->DirEntry.FatX.UpdateTime,
+                                   &pInfo->LastWriteTime);
+
+        pInfo->ChangeTime = pInfo->LastWriteTime;
         pInfo->EndOfFile.u.HighPart = 0;
         pInfo->EndOfFile.u.LowPart = DirContext->DirEntry.FatX.FileSize;
         /* Make allocsize a rounded up multiple of BytesPerCluster */
         pInfo->AllocationSize.u.HighPart = 0;
-        pInfo->AllocationSize.u.LowPart =
ROUND_UP(DirContext->DirEntry.FatX.FileSize, DeviceExt->FatInfo.BytesPerCluster);
-      }
-    pInfo->FileAttributes = DirContext->DirEntry.FatX.Attrib & 0x3f;
-  }
-  else
-  {
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.Fat.CreationDate,
-			      DirContext->DirEntry.Fat.CreationTime,
-			      &pInfo->CreationTime);
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.Fat.AccessDate, 0,
-			      &pInfo->LastAccessTime);
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.Fat.UpdateDate,
-			      DirContext->DirEntry.Fat.UpdateTime,
-			      &pInfo->LastWriteTime);
-    pInfo->ChangeTime = pInfo->LastWriteTime;
-    if (DirContext->DirEntry.Fat.Attrib & FILE_ATTRIBUTE_DIRECTORY)
-      {
-        pInfo->EndOfFile.QuadPart = 0;
-        pInfo->AllocationSize.QuadPart = 0;
-      }
+        pInfo->AllocationSize.u.LowPart =
ROUND_UP(DirContext->DirEntry.FatX.FileSize,
+                                                  
DeviceExt->FatInfo.BytesPerCluster);
+        pInfo->FileAttributes = DirContext->DirEntry.FatX.Attrib & 0x3f;
+    }
     else
-      {
+    {
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.Fat.CreationDate,
+                                   DirContext->DirEntry.Fat.CreationTime,
+                                   &pInfo->CreationTime);
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.Fat.AccessDate,
+                                   0,
+                                   &pInfo->LastAccessTime);
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.Fat.UpdateDate,
+                                   DirContext->DirEntry.Fat.UpdateTime,
+                                   &pInfo->LastWriteTime);
+
+        pInfo->ChangeTime = pInfo->LastWriteTime;
         pInfo->EndOfFile.u.HighPart = 0;
         pInfo->EndOfFile.u.LowPart = DirContext->DirEntry.Fat.FileSize;
         /* Make allocsize a rounded up multiple of BytesPerCluster */
         pInfo->AllocationSize.u.HighPart = 0;
-        pInfo->AllocationSize.u.LowPart =
ROUND_UP(DirContext->DirEntry.Fat.FileSize, DeviceExt->FatInfo.BytesPerCluster);
-      }
-    pInfo->FileAttributes = DirContext->DirEntry.Fat.Attrib & 0x3f;
-  }
-
-  return STATUS_SUCCESS;
+        pInfo->AllocationSize.u.LowPart =
ROUND_UP(DirContext->DirEntry.Fat.FileSize,
+                                                  
DeviceExt->FatInfo.BytesPerCluster);
+        pInfo->FileAttributes = DirContext->DirEntry.Fat.Attrib & 0x3f;
+    }
+
+    return STATUS_SUCCESS;
 }
 
 static NTSTATUS
-VfatGetFileFullDirectoryInformation (PVFAT_DIRENTRY_CONTEXT DirContext,
-				     PDEVICE_EXTENSION DeviceExt,
-				     PFILE_FULL_DIR_INFORMATION pInfo,
-				     ULONG BufferLength)
-{
-  if ((sizeof (FILE_FULL_DIR_INFORMATION) + DirContext->LongNameU.Length) >
BufferLength)
-    return STATUS_BUFFER_OVERFLOW;
-  pInfo->FileNameLength = DirContext->LongNameU.Length;
-  pInfo->NextEntryOffset =
-    ULONG_ROUND_UP (sizeof (FILE_FULL_DIR_INFORMATION) +
DirContext->LongNameU.Length);
-  RtlCopyMemory (pInfo->FileName, DirContext->LongNameU.Buffer,
DirContext->LongNameU.Length);
-//      pInfo->FileIndex=;
-  if (DeviceExt->Flags & VCB_IS_FATX)
-  {
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.FatX.CreationDate,
-			      DirContext->DirEntry.FatX.CreationTime,
-			      &pInfo->CreationTime);
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.FatX.AccessDate,
-                              DirContext->DirEntry.FatX.AccessTime,
-                              &pInfo->LastAccessTime);
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.FatX.UpdateDate,
-                              DirContext->DirEntry.FatX.UpdateTime,
-                              &pInfo->LastWriteTime);
-    pInfo->ChangeTime = pInfo->LastWriteTime;
-    pInfo->EndOfFile.u.HighPart = 0;
-    pInfo->EndOfFile.u.LowPart = DirContext->DirEntry.FatX.FileSize;
-    /* Make allocsize a rounded up multiple of BytesPerCluster */
-    pInfo->AllocationSize.u.HighPart = 0;
-    pInfo->AllocationSize.u.LowPart = ROUND_UP(DirContext->DirEntry.FatX.FileSize,
DeviceExt->FatInfo.BytesPerCluster);
-    pInfo->FileAttributes = DirContext->DirEntry.FatX.Attrib & 0x3f;
-  }
-  else
-  {
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.Fat.CreationDate,
-			      DirContext->DirEntry.Fat.CreationTime,
-			      &pInfo->CreationTime);
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.Fat.AccessDate,
-                              0, &pInfo->LastAccessTime);
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.Fat.UpdateDate,
-                              DirContext->DirEntry.Fat.UpdateTime,
-                              &pInfo->LastWriteTime);
-    pInfo->ChangeTime = pInfo->LastWriteTime;
-    pInfo->EndOfFile.u.HighPart = 0;
-    pInfo->EndOfFile.u.LowPart = DirContext->DirEntry.Fat.FileSize;
-    /* Make allocsize a rounded up multiple of BytesPerCluster */
-    pInfo->AllocationSize.u.HighPart = 0;
-    pInfo->AllocationSize.u.LowPart = ROUND_UP(DirContext->DirEntry.Fat.FileSize,
DeviceExt->FatInfo.BytesPerCluster);
-    pInfo->FileAttributes = DirContext->DirEntry.Fat.Attrib & 0x3f;
-  }
-//      pInfo->EaSize=;
-  return STATUS_SUCCESS;
+VfatGetFileBothInformation(PVFAT_DIRENTRY_CONTEXT DirContext,
+                           PDEVICE_EXTENSION DeviceExt,
+                           PFILE_BOTH_DIR_INFORMATION pInfo,
+                           ULONG BufferLength)
+{
+    if ((sizeof(FILE_BOTH_DIR_INFORMATION) + DirContext->LongNameU.Length) >
BufferLength)
+        return STATUS_BUFFER_OVERFLOW;
+
+    pInfo->EaSize = 0;
+
+    if (DeviceExt->Flags & VCB_IS_FATX)
+    {
+        pInfo->FileNameLength = DirContext->LongNameU.Length;
+
+        RtlCopyMemory(pInfo->FileName,
+                      DirContext->LongNameU.Buffer,
+                      DirContext->LongNameU.Length);
+
+        pInfo->NextEntryOffset = ULONG_ROUND_UP(sizeof(FILE_BOTH_DIR_INFORMATION) +
+                                                DirContext->LongNameU.Length);
+        pInfo->ShortName[0] = 0;
+        pInfo->ShortNameLength = 0;
+        /* pInfo->FileIndex = ; */
+
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.FatX.CreationDate,
+                                   DirContext->DirEntry.FatX.CreationTime,
+                                   &pInfo->CreationTime);
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.FatX.AccessDate,
+                                   DirContext->DirEntry.FatX.AccessTime,
+                                   &pInfo->LastAccessTime);
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.FatX.UpdateDate,
+                                   DirContext->DirEntry.FatX.UpdateTime,
+                                   &pInfo->LastWriteTime);
+
+        pInfo->ChangeTime = pInfo->LastWriteTime;
+
+        if (DirContext->DirEntry.FatX.Attrib & FILE_ATTRIBUTE_DIRECTORY)
+        {
+            pInfo->EndOfFile.QuadPart = 0;
+            pInfo->AllocationSize.QuadPart = 0;
+        }
+        else
+        {
+            pInfo->EndOfFile.u.HighPart = 0;
+            pInfo->EndOfFile.u.LowPart = DirContext->DirEntry.FatX.FileSize;
+            /* Make allocsize a rounded up multiple of BytesPerCluster */
+            pInfo->AllocationSize.u.HighPart = 0;
+            pInfo->AllocationSize.u.LowPart =
ROUND_UP(DirContext->DirEntry.FatX.FileSize,
+                                                      
DeviceExt->FatInfo.BytesPerCluster);
+        }
+
+        pInfo->FileAttributes = DirContext->DirEntry.FatX.Attrib & 0x3f;
+    }
+    else
+    {
+        pInfo->FileNameLength = DirContext->LongNameU.Length;
+        pInfo->NextEntryOffset = ULONG_ROUND_UP(sizeof(FILE_BOTH_DIR_INFORMATION) +
+                                                DirContext->LongNameU.Length);
+
+        RtlCopyMemory(pInfo->ShortName,
+                      DirContext->ShortNameU.Buffer,
+                      DirContext->ShortNameU.Length);
+
+        pInfo->ShortNameLength = (CCHAR)DirContext->ShortNameU.Length;
+
+        RtlCopyMemory(pInfo->FileName,
+                      DirContext->LongNameU.Buffer,
+                      DirContext->LongNameU.Length);
+
+        /* pInfo->FileIndex = ; */
+
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.Fat.CreationDate,
+                                   DirContext->DirEntry.Fat.CreationTime,
+                                   &pInfo->CreationTime);
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.Fat.AccessDate,
+                                   0,
+                                   &pInfo->LastAccessTime);
+        FsdDosDateTimeToSystemTime(DeviceExt,
+                                   DirContext->DirEntry.Fat.UpdateDate,
+                                   DirContext->DirEntry.Fat.UpdateTime,
+                                   &pInfo->LastWriteTime);
+
+        pInfo->ChangeTime = pInfo->LastWriteTime;
+
+        if (DirContext->DirEntry.Fat.Attrib & FILE_ATTRIBUTE_DIRECTORY)
+        {
+            pInfo->EndOfFile.QuadPart = 0;
+            pInfo->AllocationSize.QuadPart = 0;
+        }
+        else
+        {
+            pInfo->EndOfFile.u.HighPart = 0;
+            pInfo->EndOfFile.u.LowPart = DirContext->DirEntry.Fat.FileSize;
+            /* Make allocsize a rounded up multiple of BytesPerCluster */
+            pInfo->AllocationSize.u.HighPart = 0;
+            pInfo->AllocationSize.u.LowPart =
ROUND_UP(DirContext->DirEntry.Fat.FileSize, DeviceExt->FatInfo.BytesPerCluster);
+        }
+
+        pInfo->FileAttributes = DirContext->DirEntry.Fat.Attrib & 0x3f;
+    }
+
+    return STATUS_SUCCESS;
 }
 
 static NTSTATUS
-VfatGetFileBothInformation (PVFAT_DIRENTRY_CONTEXT DirContext,
-			    PDEVICE_EXTENSION DeviceExt,
-			    PFILE_BOTH_DIR_INFORMATION pInfo,
-			    ULONG BufferLength)
-{
-  if ((sizeof (FILE_BOTH_DIR_INFORMATION) + DirContext->LongNameU.Length) >
BufferLength)
-    return STATUS_BUFFER_OVERFLOW;
-
-  if (DeviceExt->Flags & VCB_IS_FATX)
-  {
-    pInfo->FileNameLength = DirContext->LongNameU.Length;
-    RtlCopyMemory(pInfo->FileName, DirContext->LongNameU.Buffer,
DirContext->LongNameU.Length);
-    pInfo->NextEntryOffset =
-      ULONG_ROUND_UP (sizeof (FILE_BOTH_DIR_INFORMATION) +
DirContext->LongNameU.Length);
-    pInfo->ShortName[0] = 0;
-    pInfo->ShortNameLength = 0;
-    //      pInfo->FileIndex=;
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.FatX.CreationDate,
-                              DirContext->DirEntry.FatX.CreationTime,
-                              &pInfo->CreationTime);
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.FatX.AccessDate,
-                              DirContext->DirEntry.FatX.AccessTime,
-                              &pInfo->LastAccessTime);
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.FatX.UpdateDate,
-                              DirContext->DirEntry.FatX.UpdateTime,
-                              &pInfo->LastWriteTime);
-    pInfo->ChangeTime = pInfo->LastWriteTime;
-    if (DirContext->DirEntry.FatX.Attrib & FILE_ATTRIBUTE_DIRECTORY)
-      {
-        pInfo->EndOfFile.QuadPart = 0;
-        pInfo->AllocationSize.QuadPart = 0;
-      }
+DoQuery(PVFAT_IRP_CONTEXT IrpContext)
+{
+    NTSTATUS Status = STATUS_SUCCESS;
+    LONG BufferLength = 0;
+    PUNICODE_STRING pSearchPattern = NULL;
+    FILE_INFORMATION_CLASS FileInformationClass;
+    PUCHAR Buffer = NULL;
+    PFILE_NAMES_INFORMATION Buffer0 = NULL;
+    PVFATFCB pFcb;
+    PVFATCCB pCcb;
+    BOOLEAN FirstQuery = FALSE;
+    BOOLEAN FirstCall = TRUE;
+    VFAT_DIRENTRY_CONTEXT DirContext;
+    WCHAR LongNameBuffer[LONGNAME_MAX_LENGTH + 1];
+    WCHAR ShortNameBuffer[13];
+
+    PIO_STACK_LOCATION Stack = IrpContext->Stack;
+
+    pCcb = (PVFATCCB)IrpContext->FileObject->FsContext2;
+    pFcb = (PVFATFCB)IrpContext->FileObject->FsContext;
+
+    /* Determine Buffer for result : */
+    BufferLength = Stack->Parameters.QueryDirectory.Length;
+#if 0
+    /* Do not probe the user buffer until SEH is available */
+    if (IrpContext->Irp->RequestorMode != KernelMode &&
+        IrpContext->Irp->MdlAddress == NULL &&
+        IrpContext->Irp->UserBuffer != NULL)
+    {
+        ProbeForWrite(IrpContext->Irp->UserBuffer, BufferLength, 1);
+    }
+#endif
+    Buffer = VfatGetUserBuffer(IrpContext->Irp);
+
+    if (!ExAcquireResourceSharedLite(&pFcb->MainResource,
+                                     (BOOLEAN)(IrpContext->Flags &
IRPCONTEXT_CANWAIT)))
+    {
+        Status = VfatLockUserBuffer(IrpContext->Irp, BufferLength, IoWriteAccess);
+        if (NT_SUCCESS(Status))
+            Status = STATUS_PENDING;
+
+        return Status;
+    }
+
+    /* Obtain the callers parameters */
+#ifdef _MSC_VER
+    /* HACKHACK: Bug in the MS ntifs.h header:
+     * FileName is really a PUNICODE_STRING, not a PSTRING */
+    pSearchPattern = (PUNICODE_STRING)Stack->Parameters.QueryDirectory.FileName;
+#else
+    pSearchPattern = Stack->Parameters.QueryDirectory.FileName;
+#endif
+    FileInformationClass = Stack->Parameters.QueryDirectory.FileInformationClass;
+
+    if (pSearchPattern)
+    {
+        if (!pCcb->SearchPattern.Buffer)
+        {
+            FirstQuery = TRUE;
+            pCcb->SearchPattern.MaximumLength = pSearchPattern->Length +
sizeof(WCHAR);
+            pCcb->SearchPattern.Buffer = ExAllocatePoolWithTag(NonPagedPool,
+                                                              
pCcb->SearchPattern.MaximumLength,
+                                                               TAG_VFAT);
+            if (!pCcb->SearchPattern.Buffer)
+            {
+                ExReleaseResourceLite(&pFcb->MainResource);
+                return STATUS_INSUFFICIENT_RESOURCES;
+            }
+            RtlCopyUnicodeString(&pCcb->SearchPattern, pSearchPattern);
+            pCcb->SearchPattern.Buffer[pCcb->SearchPattern.Length / sizeof(WCHAR)]
= 0;
+        }
+    }
+    else if (!pCcb->SearchPattern.Buffer)
+    {
+        FirstQuery = TRUE;
+        pCcb->SearchPattern.MaximumLength = 2 * sizeof(WCHAR);
+        pCcb->SearchPattern.Buffer = ExAllocatePoolWithTag(NonPagedPool,
+                                                           2 * sizeof(WCHAR),
+                                                           TAG_VFAT);
+        if (!pCcb->SearchPattern.Buffer)
+        {
+            ExReleaseResourceLite(&pFcb->MainResource);
+            return STATUS_INSUFFICIENT_RESOURCES;
+        }
+        pCcb->SearchPattern.Buffer[0] = L'*';
+        pCcb->SearchPattern.Buffer[1] = 0;
+        pCcb->SearchPattern.Length = sizeof(WCHAR);
+    }
+
+    if (IrpContext->Stack->Flags & SL_INDEX_SPECIFIED)
+    {
+        DirContext.DirIndex = pCcb->Entry =
Stack->Parameters.QueryDirectory.FileIndex;
+    }
+    else if (FirstQuery || (IrpContext->Stack->Flags & SL_RESTART_SCAN))
+    {
+        DirContext.DirIndex = pCcb->Entry = 0;
+    }
     else
-      {
-        pInfo->EndOfFile.u.HighPart = 0;
-        pInfo->EndOfFile.u.LowPart = DirContext->DirEntry.FatX.FileSize;
-        /* Make allocsize a rounded up multiple of BytesPerCluster */
-        pInfo->AllocationSize.u.HighPart = 0;
-        pInfo->AllocationSize.u.LowPart =
ROUND_UP(DirContext->DirEntry.FatX.FileSize, DeviceExt->FatInfo.BytesPerCluster);
-      }
-    pInfo->FileAttributes = DirContext->DirEntry.FatX.Attrib & 0x3f;
-  }
-  else
-  {
-    pInfo->FileNameLength = DirContext->LongNameU.Length;
-    pInfo->NextEntryOffset =
-      ULONG_ROUND_UP (sizeof (FILE_BOTH_DIR_INFORMATION) +
DirContext->LongNameU.Length);
-    RtlCopyMemory(pInfo->ShortName, DirContext->ShortNameU.Buffer,
DirContext->ShortNameU.Length);
-    pInfo->ShortNameLength = (CCHAR)DirContext->ShortNameU.Length;
-    RtlCopyMemory (pInfo->FileName, DirContext->LongNameU.Buffer,
DirContext->LongNameU.Length);
-  //      pInfo->FileIndex=;
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.Fat.CreationDate,
-                              DirContext->DirEntry.Fat.CreationTime,
-                              &pInfo->CreationTime);
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.Fat.AccessDate, 0,
-                              &pInfo->LastAccessTime);
-    FsdDosDateTimeToSystemTime (DeviceExt, DirContext->DirEntry.Fat.UpdateDate,
-                              DirContext->DirEntry.Fat.UpdateTime,
-                              &pInfo->LastWriteTime);
-    pInfo->ChangeTime = pInfo->LastWriteTime;
-    if (DirContext->DirEntry.Fat.Attrib & FILE_ATTRIBUTE_DIRECTORY)
-      {
-        pInfo->EndOfFile.QuadPart = 0;
-        pInfo->AllocationSize.QuadPart = 0;
-      }
-    else
-      {
-        pInfo->EndOfFile.u.HighPart = 0;
-        pInfo->EndOfFile.u.LowPart = DirContext->DirEntry.Fat.FileSize;
-        /* Make allocsize a rounded up multiple of BytesPerCluster */
-        pInfo->AllocationSize.u.HighPart = 0;
-        pInfo->AllocationSize.u.LowPart =
ROUND_UP(DirContext->DirEntry.Fat.FileSize, DeviceExt->FatInfo.BytesPerCluster);
-      }
-    pInfo->FileAttributes = DirContext->DirEntry.Fat.Attrib & 0x3f;
-  }
-  pInfo->EaSize=0;
-  return STATUS_SUCCESS;
-}
-
-static NTSTATUS DoQuery (PVFAT_IRP_CONTEXT IrpContext)
-{
-  NTSTATUS RC = STATUS_SUCCESS;
-  long BufferLength = 0;
-  PUNICODE_STRING pSearchPattern = NULL;
-  FILE_INFORMATION_CLASS FileInformationClass;
-  unsigned char *Buffer = NULL;
-  PFILE_NAMES_INFORMATION Buffer0 = NULL;
-  PVFATFCB pFcb;
-  PVFATCCB pCcb;
-  BOOLEAN FirstQuery = FALSE;
-  BOOLEAN FirstCall = TRUE;
-  VFAT_DIRENTRY_CONTEXT DirContext;
-  WCHAR LongNameBuffer[LONGNAME_MAX_LENGTH + 1];
-  WCHAR ShortNameBuffer[13];
-
-  PIO_STACK_LOCATION Stack = IrpContext->Stack;
-
-  pCcb = (PVFATCCB) IrpContext->FileObject->FsContext2;
-  pFcb = (PVFATFCB) IrpContext->FileObject->FsContext;
-
-  // determine Buffer for result :
-  BufferLength = Stack->Parameters.QueryDirectory.Length;
-#if 0
-  /* Do not probe the user buffer until SEH is available */
-  if (IrpContext->Irp->RequestorMode != KernelMode &&
-      IrpContext->Irp->MdlAddress == NULL &&
-      IrpContext->Irp->UserBuffer != NULL)
-    {
-      ProbeForWrite(IrpContext->Irp->UserBuffer, BufferLength, 1);
-    }
-#endif
-  Buffer = VfatGetUserBuffer(IrpContext->Irp);
-
-  if (!ExAcquireResourceSharedLite(&pFcb->MainResource,
-                                   (BOOLEAN)(IrpContext->Flags &
IRPCONTEXT_CANWAIT)))
-    {
-      RC = VfatLockUserBuffer(IrpContext->Irp, BufferLength, IoWriteAccess);
-      if (NT_SUCCESS(RC))
-        {
-          RC = STATUS_PENDING;
-        }
-      return RC;
-    }
-
-  /* Obtain the callers parameters */
-#ifdef _MSC_VER
-  /* HACKHACK: Bug in the MS ntifs.h header:
-   * FileName is really a PUNICODE_STRING, not a PSTRING */
-  pSearchPattern = (PUNICODE_STRING)Stack->Parameters.QueryDirectory.FileName;
-#else
-  pSearchPattern = Stack->Parameters.QueryDirectory.FileName;
-#endif
-  FileInformationClass =
-    Stack->Parameters.QueryDirectory.FileInformationClass;
-  if (pSearchPattern)
-    {
-      if (!pCcb->SearchPattern.Buffer)
-        {
-          FirstQuery = TRUE;
-          pCcb->SearchPattern.MaximumLength = pSearchPattern->Length +
sizeof(WCHAR);
-          pCcb->SearchPattern.Buffer = ExAllocatePoolWithTag(NonPagedPool,
pCcb->SearchPattern.MaximumLength, TAG_VFAT);
-          if (!pCcb->SearchPattern.Buffer)
+    {
+        DirContext.DirIndex = pCcb->Entry;
+    }
+
+    DPRINT("Buffer=%p tofind=%wZ\n", Buffer, &pCcb->SearchPattern);
+
+    DirContext.LongNameU.Buffer = LongNameBuffer;
+    DirContext.LongNameU.MaximumLength = sizeof(LongNameBuffer);
+    DirContext.ShortNameU.Buffer = ShortNameBuffer;
+    DirContext.ShortNameU.MaximumLength = sizeof(ShortNameBuffer);
+
+    while ((Status == STATUS_SUCCESS) && (BufferLength > 0))
+    {
+        Status = FindFile(IrpContext->DeviceExt,
+                          pFcb,
+                          &pCcb->SearchPattern,
+                          &DirContext,
+                          FirstCall);
+        pCcb->Entry = DirContext.DirIndex;
+
+        DPRINT("Found %wZ, Status=%x, entry %x\n", &DirContext.LongNameU,
Status, pCcb->Entry);
+
+        FirstCall = FALSE;
+        if (NT_SUCCESS(Status))
+        {
+            switch (FileInformationClass)
             {
-              ExReleaseResourceLite(&pFcb->MainResource);
-              return STATUS_INSUFFICIENT_RESOURCES;
+                case FileNameInformation:
+                    Status = VfatGetFileNameInformation(&DirContext,
+                                                        (PFILE_NAMES_INFORMATION)Buffer,
+                                                        BufferLength);
+                    break;
+
+                case FileDirectoryInformation:
+                    Status = VfatGetFileDirectoryInformation(&DirContext,
+                                                             IrpContext->DeviceExt,
+                                                            
(PFILE_DIRECTORY_INFORMATION)Buffer,
+                                                             BufferLength);
+                    break;
+
+                case FileFullDirectoryInformation:
+                    Status = VfatGetFileFullDirectoryInformation(&DirContext,
+                                                                
IrpContext->DeviceExt,
+                                                                
(PFILE_FULL_DIR_INFORMATION)Buffer,
+                                                                 BufferLength);
+                    break;
+
+                case FileBothDirectoryInformation:
+                    Status = VfatGetFileBothInformation(&DirContext,
+                                                        IrpContext->DeviceExt,
+                                                       
(PFILE_BOTH_DIR_INFORMATION)Buffer,
+                                                        BufferLength);
+                    break;
+
+                default:
+                    Status = STATUS_INVALID_INFO_CLASS;
+                    break;
             }
-          RtlCopyUnicodeString(&pCcb->SearchPattern, pSearchPattern);
-          pCcb->SearchPattern.Buffer[pCcb->SearchPattern.Length / sizeof(WCHAR)] =
0;
-	}
-    }
-  else if (!pCcb->SearchPattern.Buffer)
-    {
-      FirstQuery = TRUE;
-      pCcb->SearchPattern.MaximumLength = 2 * sizeof(WCHAR);
-      pCcb->SearchPattern.Buffer = ExAllocatePoolWithTag(NonPagedPool, 2 *
sizeof(WCHAR), TAG_VFAT);
-      if (!pCcb->SearchPattern.Buffer)
-        {
-          ExReleaseResourceLite(&pFcb->MainResource);
-          return STATUS_INSUFFICIENT_RESOURCES;
-        }
-      pCcb->SearchPattern.Buffer[0] = L'*';
-      pCcb->SearchPattern.Buffer[1] = 0;
-      pCcb->SearchPattern.Length = sizeof(WCHAR);
-    }
-
-  if (IrpContext->Stack->Flags & SL_INDEX_SPECIFIED)
-    {
-      DirContext.DirIndex = pCcb->Entry =
Stack->Parameters.QueryDirectory.FileIndex;
-    }
-  else if (FirstQuery || (IrpContext->Stack->Flags & SL_RESTART_SCAN))
-    {
-      DirContext.DirIndex = pCcb->Entry = 0;
-    }
-  else
-    {
-      DirContext.DirIndex = pCcb->Entry;
-    }
-
-  DPRINT ("Buffer=%p tofind=%wZ\n", Buffer, &pCcb->SearchPattern);
-
-  DirContext.LongNameU.Buffer = LongNameBuffer;
-  DirContext.LongNameU.MaximumLength = sizeof(LongNameBuffer);
-  DirContext.ShortNameU.Buffer = ShortNameBuffer;
-  DirContext.ShortNameU.MaximumLength = sizeof(ShortNameBuffer);
-
-  while (RC == STATUS_SUCCESS && BufferLength > 0)
-    {
-      RC = FindFile (IrpContext->DeviceExt, pFcb,
-                     &pCcb->SearchPattern, &DirContext, FirstCall);
-      pCcb->Entry = DirContext.DirIndex;
-      DPRINT ("Found %wZ, RC=%x, entry %x\n", &DirContext.LongNameU, RC,
pCcb->Entry);
-      FirstCall = FALSE;
-      if (NT_SUCCESS (RC))
-        {
-          switch (FileInformationClass)
-            {
-              case FileNameInformation:
-                RC = VfatGetFileNameInformation (&DirContext,
-                                                 (PFILE_NAMES_INFORMATION) Buffer,
-					         BufferLength);
+
+            if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_INVALID_INFO_CLASS)
                 break;
-              case FileDirectoryInformation:
-                RC = VfatGetFileDirectoryInformation (&DirContext,
-	                                              IrpContext->DeviceExt,
-						      (PFILE_DIRECTORY_INFORMATION) Buffer,
-						      BufferLength);
-                break;
-             case FileFullDirectoryInformation:
-               RC = VfatGetFileFullDirectoryInformation (&DirContext,
-	                                                 IrpContext->DeviceExt,
-						         (PFILE_FULL_DIR_INFORMATION) Buffer,
-						         BufferLength);
-               break;
-             case FileBothDirectoryInformation:
-               RC = VfatGetFileBothInformation (&DirContext,
-	                                        IrpContext->DeviceExt,
-					        (PFILE_BOTH_DIR_INFORMATION) Buffer,
-					        BufferLength);
-               break;
-             default:
-               RC = STATUS_INVALID_INFO_CLASS;
-	    }
-          if (RC == STATUS_BUFFER_OVERFLOW || RC == STATUS_INVALID_INFO_CLASS)
-            {
-              break;
-            }
-	}
-      else
-        {
-          if (FirstQuery)
-            {
-              RC = STATUS_NO_SUCH_FILE;
-            }
-          else
-            {
-              RC = STATUS_NO_MORE_FILES;
-            }
-          break;
-	}
-      Buffer0 = (PFILE_NAMES_INFORMATION) Buffer;
-      Buffer0->FileIndex = DirContext.DirIndex;
-      pCcb->Entry = ++DirContext.DirIndex;
-      BufferLength -= Buffer0->NextEntryOffset;
-      if (IrpContext->Stack->Flags & SL_RETURN_SINGLE_ENTRY)
-        {
-          break;
-        }
-      Buffer += Buffer0->NextEntryOffset;
-    }
-  if (Buffer0)
-    {
-      Buffer0->NextEntryOffset = 0;
-      RC = STATUS_SUCCESS;
-      IrpContext->Irp->IoStatus.Information =
Stack->Parameters.QueryDirectory.Length - BufferLength;
-
-    }
-  ExReleaseResourceLite(&pFcb->MainResource);
-  return RC;
-}
-
-
-NTSTATUS VfatDirectoryControl (PVFAT_IRP_CONTEXT IrpContext)
+        }
+        else
+        {
+            Status = (FirstQuery ? STATUS_NO_SUCH_FILE : STATUS_NO_MORE_FILES);
+            break;
+        }
+
+        Buffer0 = (PFILE_NAMES_INFORMATION) Buffer;
+        Buffer0->FileIndex = DirContext.DirIndex;
+        pCcb->Entry = ++DirContext.DirIndex;
+        BufferLength -= Buffer0->NextEntryOffset;
+
+        if (IrpContext->Stack->Flags & SL_RETURN_SINGLE_ENTRY)
+            break;
+
+        Buffer += Buffer0->NextEntryOffset;
+    }
+
+    if (Buffer0)
+    {
+        Buffer0->NextEntryOffset = 0;
+        Status = STATUS_SUCCESS;
+        IrpContext->Irp->IoStatus.Information =
Stack->Parameters.QueryDirectory.Length - BufferLength;
+    }
+
+    ExReleaseResourceLite(&pFcb->MainResource);
+
+    return Status;
+}
+
+
 /*
  * FUNCTION: directory control : read/write directory informations
  */
-{
-  NTSTATUS RC = STATUS_SUCCESS;
-  IrpContext->Irp->IoStatus.Information = 0;
-  switch (IrpContext->MinorFunction)
-    {
-    case IRP_MN_QUERY_DIRECTORY:
-      RC = DoQuery (IrpContext);
-      break;
-    case IRP_MN_NOTIFY_CHANGE_DIRECTORY:
-      DPRINT (" vfat, dir : change\n");
-      RC = STATUS_NOT_IMPLEMENTED;
-      break;
-    default:
-      // error
-      DbgPrint ("unexpected minor function %x in VFAT driver\n",
-		IrpContext->MinorFunction);
-      RC = STATUS_INVALID_DEVICE_REQUEST;
-      break;
-    }
-  if (RC == STATUS_PENDING)
-  {
-     RC = VfatQueueRequest(IrpContext);
-  }
-  else
-  {
-    IrpContext->Irp->IoStatus.Status = RC;
-    IoCompleteRequest (IrpContext->Irp, IO_NO_INCREMENT);
-    VfatFreeIrpContext(IrpContext);
-  }
-  return RC;
-}
-
-
+NTSTATUS
+VfatDirectoryControl(PVFAT_IRP_CONTEXT IrpContext)
+{
+    NTSTATUS Status = STATUS_SUCCESS;
+
+    IrpContext->Irp->IoStatus.Information = 0;
+
+    switch (IrpContext->MinorFunction)
+    {
+        case IRP_MN_QUERY_DIRECTORY:
+            Status = DoQuery (IrpContext);
+            break;
+
+        case IRP_MN_NOTIFY_CHANGE_DIRECTORY:
+            DPRINT("VFAT, dir : change\n");
+            Status = STATUS_NOT_IMPLEMENTED;
+            break;
+
+        default:
+            /* Error */
+            DPRINT("Unexpected minor function %x in VFAT driver\n",
+                   IrpContext->MinorFunction);
+            Status = STATUS_INVALID_DEVICE_REQUEST;
+            break;
+    }
+
+    if (Status == STATUS_PENDING)
+    {
+        Status = VfatQueueRequest(IrpContext);
+    }
+    else
+    {
+        IrpContext->Irp->IoStatus.Status = Status;
+        IoCompleteRequest (IrpContext->Irp, IO_NO_INCREMENT);
+        VfatFreeIrpContext(IrpContext);
+    }
+
+    return Status;
+}
+
+/* EOF */