reactos/drivers/fs/vfat/dir.c

   1 /*
   2  * $Id: dir.c,v 1.20 2001/10/10 22:13:26 hbirr Exp $
   3  *
   4  * COPYRIGHT:        See COPYING in the top level directory
   5  * PROJECT:          ReactOS kernel
   6  * FILE:             services/fs/vfat/dir.c
   7  * PURPOSE:          VFAT Filesystem : directory control
   8  * UPDATE HISTORY:
   9      19-12-1998 : created
  10
  11 */
  12
  13 #include <ddk/ntddk.h>
  14 #include <wchar.h>
  15
  16 #define NDEBUG
  17 #include <debug.h>
  18
  19 #include "vfat.h"
  20
  21
  22 // function like DosDateTimeToFileTime
  23 BOOL FsdDosDateTimeToFileTime (WORD wDosDate, WORD wDosTime, TIME * FileTime)
  24 {
  25   PDOSTIME pdtime = (PDOSTIME) & wDosTime;
  26   PDOSDATE pddate = (PDOSDATE) & wDosDate;
  27   TIME_FIELDS TimeFields;
  28
  29   if (FileTime == NULL)
  30     return FALSE;
  31
  32   TimeFields.Milliseconds = 0;
  33   TimeFields.Second = pdtime->Second * 2;
  34   TimeFields.Minute = pdtime->Minute;
  35   TimeFields.Hour = pdtime->Hour;
  36
  37   TimeFields.Day = pddate->Day;
  38   TimeFields.Month = pddate->Month;
  39   TimeFields.Year = 1980 + pddate->Year;
  40
  41   RtlTimeFieldsToTime (&TimeFields, (PLARGE_INTEGER) FileTime);
  42
  43   return TRUE;
  44 }
  45
  46
  47 // function like FileTimeToDosDateTime
  48 BOOL
  49 FsdFileTimeToDosDateTime (TIME * FileTime, WORD * pwDosDate, WORD * pwDosTime)
  50 {
  51   PDOSTIME pdtime = (PDOSTIME) pwDosTime;
  52   PDOSDATE pddate = (PDOSDATE) pwDosDate;
  53   TIME_FIELDS TimeFields;
  54
  55   if (FileTime == NULL)
  56     return FALSE;
  57
  58   RtlTimeToTimeFields ((PLARGE_INTEGER) FileTime, &TimeFields);
  59
  60   if (pdtime)
  61     {
  62       pdtime->Second = TimeFields.Second / 2;
  63       pdtime->Minute = TimeFields.Minute;
  64       pdtime->Hour = TimeFields.Hour;
  65     }
  66
  67   if (pddate)
  68     {
  69       pddate->Day = TimeFields.Day;
  70       pddate->Month = TimeFields.Month;
  71       pddate->Year = TimeFields.Year - 1980;
  72     }
  73
  74   return TRUE;
  75 }
  76
  77
  78
  79 unsigned long
  80 vfat_wstrlen (PWSTR s)
  81 {
  82   WCHAR c = ' ';
  83   unsigned int len = 0;
  84
  85   while (c != 0)
  86     {
  87       c = *s;
  88       s++;
  89       len++;
  90     };
  91   s -= len;
  92
  93   return len - 1;
  94 }
  95
  96 #define DWORD_ROUND_UP(x) ( (((ULONG)(x))%32) ? ((((ULONG)x)&(~0x1f))+0x20) : ((ULONG)x) )
  97
  98 NTSTATUS
  99 VfatGetFileNameInformation (PVFATFCB pFcb,
 100                            PFILE_NAMES_INFORMATION pInfo, ULONG BufferLength)
 101 {
 102   ULONG Length;
 103   Length = vfat_wstrlen (pFcb->ObjectName);
 104   if ((sizeof (FILE_DIRECTORY_INFORMATION) + Length * sizeof(WCHAR)) > BufferLength)
 105     return STATUS_BUFFER_OVERFLOW;
 106   pInfo->FileNameLength = Length;
 107   pInfo->NextEntryOffset =
 108     DWORD_ROUND_UP (sizeof (FILE_DIRECTORY_INFORMATION) + Length * sizeof(WCHAR));
 109   memcpy (pInfo->FileName, pFcb->ObjectName,
 110           sizeof (WCHAR) * (pInfo->FileNameLength));
 111   return STATUS_SUCCESS;
 112 }
 113
 114 NTSTATUS
 115 VfatGetFileDirectoryInformation (PVFATFCB pFcb,
 116                                 PDEVICE_EXTENSION DeviceExt,
 117                                 PFILE_DIRECTORY_INFORMATION pInfo,
 118                                 ULONG BufferLength)
 119 {
 120   unsigned long long AllocSize;
 121   ULONG Length;
 122   Length = vfat_wstrlen (pFcb->ObjectName);
 123   if ((sizeof (FILE_DIRECTORY_INFORMATION) + Length * sizeof(WCHAR)) > BufferLength)
 124     return STATUS_BUFFER_OVERFLOW;
 125   pInfo->FileNameLength = Length;
 126   pInfo->NextEntryOffset =
 127     DWORD_ROUND_UP (sizeof (FILE_DIRECTORY_INFORMATION) + Length * sizeof(WCHAR));
 128   memcpy (pInfo->FileName, pFcb->ObjectName,
 129           sizeof (WCHAR) * (pInfo->FileNameLength));
 130 //      pInfo->FileIndex=;
 131   FsdDosDateTimeToFileTime (pFcb->entry.CreationDate,
 132                             pFcb->entry.CreationTime, &pInfo->CreationTime);
 133   FsdDosDateTimeToFileTime (pFcb->entry.AccessDate, 0,
 134                             &pInfo->LastAccessTime);
 135   FsdDosDateTimeToFileTime (pFcb->entry.UpdateDate, pFcb->entry.UpdateTime,
 136                             &pInfo->LastWriteTime);
 137   FsdDosDateTimeToFileTime (pFcb->entry.UpdateDate, pFcb->entry.UpdateTime,
 138                             &pInfo->ChangeTime);
 139   pInfo->EndOfFile = RtlConvertUlongToLargeInteger (pFcb->entry.FileSize);
 140   /* Make allocsize a rounded up multiple of BytesPerCluster */
 141   AllocSize = ((pFcb->entry.FileSize + DeviceExt->BytesPerCluster - 1) /
 142                DeviceExt->BytesPerCluster) * DeviceExt->BytesPerCluster;
 143   pInfo->AllocationSize.QuadPart = AllocSize;
 144   pInfo->FileAttributes = pFcb->entry.Attrib;
 145
 146   return STATUS_SUCCESS;
 147 }
 148
 149 NTSTATUS
 150 VfatGetFileFullDirectoryInformation (PVFATFCB pFcb,
 151                                     PDEVICE_EXTENSION DeviceExt,
 152                                     PFILE_FULL_DIRECTORY_INFORMATION pInfo,
 153                                     ULONG BufferLength)
 154 {
 155   unsigned long long AllocSize;
 156   ULONG Length;
 157   Length = vfat_wstrlen (pFcb->ObjectName);
 158   if ((sizeof (FILE_FULL_DIRECTORY_INFORMATION) + Length * sizeof(WCHAR)) > BufferLength)
 159     return STATUS_BUFFER_OVERFLOW;
 160   pInfo->FileNameLength = Length;
 161   pInfo->NextEntryOffset =
 162     DWORD_ROUND_UP (sizeof (FILE_FULL_DIRECTORY_INFORMATION) + Length * sizeof(WCHAR));
 163   memcpy (pInfo->FileName, pFcb->ObjectName,
 164           sizeof (WCHAR) * (pInfo->FileNameLength));
 165 //      pInfo->FileIndex=;
 166   FsdDosDateTimeToFileTime (pFcb->entry.CreationDate,
 167                             pFcb->entry.CreationTime, &pInfo->CreationTime);
 168   FsdDosDateTimeToFileTime (pFcb->entry.AccessDate, 0,
 169                             &pInfo->LastAccessTime);
 170   FsdDosDateTimeToFileTime (pFcb->entry.UpdateDate, pFcb->entry.UpdateTime,
 171                             &pInfo->LastWriteTime);
 172   FsdDosDateTimeToFileTime (pFcb->entry.UpdateDate, pFcb->entry.UpdateTime,
 173                             &pInfo->ChangeTime);
 174   pInfo->EndOfFile = RtlConvertUlongToLargeInteger (pFcb->entry.FileSize);
 175   /* Make allocsize a rounded up multiple of BytesPerCluster */
 176   AllocSize = ((pFcb->entry.FileSize + DeviceExt->BytesPerCluster - 1) /
 177                DeviceExt->BytesPerCluster) * DeviceExt->BytesPerCluster;
 178   pInfo->AllocationSize.QuadPart = AllocSize;
 179   pInfo->FileAttributes = pFcb->entry.Attrib;
 180 //      pInfo->EaSize=;
 181   return STATUS_SUCCESS;
 182 }
 183
 184 NTSTATUS
 185 VfatGetFileBothInformation (PVFATFCB pFcb,
 186                            PDEVICE_EXTENSION DeviceExt,
 187                            PFILE_BOTH_DIRECTORY_INFORMATION pInfo,
 188                            ULONG BufferLength)
 189 {
 190   short i;
 191   unsigned long long AllocSize;
 192   ULONG Length;
 193   Length = vfat_wstrlen (pFcb->ObjectName);
 194   if ((sizeof (FILE_BOTH_DIRECTORY_INFORMATION) + Length * sizeof(WCHAR)) > BufferLength)
 195     return STATUS_BUFFER_OVERFLOW;
 196   pInfo->FileNameLength = Length;
 197   pInfo->NextEntryOffset =
 198     DWORD_ROUND_UP (sizeof (FILE_BOTH_DIRECTORY_INFORMATION) + Length * sizeof(WCHAR));
 199   memcpy (pInfo->FileName, pFcb->ObjectName,
 200           sizeof (WCHAR) * (pInfo->FileNameLength));
 201 //      pInfo->FileIndex=;
 202   FsdDosDateTimeToFileTime (pFcb->entry.CreationDate,
 203                             pFcb->entry.CreationTime, &pInfo->CreationTime);
 204   FsdDosDateTimeToFileTime (pFcb->entry.AccessDate, 0,
 205                             &pInfo->LastAccessTime);
 206   FsdDosDateTimeToFileTime (pFcb->entry.UpdateDate, pFcb->entry.UpdateTime,
 207                             &pInfo->LastWriteTime);
 208   FsdDosDateTimeToFileTime (pFcb->entry.UpdateDate, pFcb->entry.UpdateTime,
 209                             &pInfo->ChangeTime);
 210   pInfo->EndOfFile = RtlConvertUlongToLargeInteger (pFcb->entry.FileSize);
 211   /* Make allocsize a rounded up multiple of BytesPerCluster */
 212   AllocSize = ((pFcb->entry.FileSize + DeviceExt->BytesPerCluster - 1) /
 213                DeviceExt->BytesPerCluster) * DeviceExt->BytesPerCluster;
 214   pInfo->AllocationSize.QuadPart = AllocSize;
 215   pInfo->FileAttributes = pFcb->entry.Attrib;
 216 //      pInfo->EaSize=;
 217   for (i = 0; i < 8 && (pFcb->entry.Filename[i] != ' '); i++)
 218     pInfo->ShortName[i] = pFcb->entry.Filename[i];
 219   pInfo->ShortNameLength = i;
 220   pInfo->ShortName[i] = '.';
 221   for (i = 0; i < 3 && (pFcb->entry.Ext[i] != ' '); i++)
 222     pInfo->ShortName[i + 1 + pInfo->ShortNameLength] = pFcb->entry.Ext[i];
 223   if (i)
 224     pInfo->ShortNameLength += (i + 1);
 225   return STATUS_SUCCESS;
 226 }
 227
 228 NTSTATUS
 229 DoQuery (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION Stack)
 230 {
 231   NTSTATUS RC = STATUS_SUCCESS;
 232   long BufferLength = 0;
 233   PUNICODE_STRING pSearchPattern = NULL;
 234   FILE_INFORMATION_CLASS FileInformationClass;
 235   unsigned long FileIndex = 0;
 236   unsigned char *Buffer = NULL;
 237   PFILE_NAMES_INFORMATION Buffer0 = NULL;
 238   PFILE_OBJECT pFileObject = NULL;
 239   PVFATFCB pFcb;
 240   VFATFCB tmpFcb;
 241   PVFATCCB pCcb;
 242   PDEVICE_EXTENSION DeviceExt;
 243   WCHAR star[5], *pCharPattern;
 244   unsigned long OldEntry, OldSector;
 245   DeviceExt = DeviceObject->DeviceExtension;
 246   // Obtain the callers parameters
 247   BufferLength = Stack->Parameters.QueryDirectory.Length;
 248   pSearchPattern = Stack->Parameters.QueryDirectory.FileName;
 249   FileInformationClass =
 250     Stack->Parameters.QueryDirectory.FileInformationClass;
 251   FileIndex = Stack->Parameters.QueryDirectory.FileIndex;
 252   pFileObject = Stack->FileObject;
 253   pCcb = (PVFATCCB) pFileObject->FsContext2;
 254   pFcb = pCcb->pFcb;
 255   if (Stack->Flags & SL_RESTART_SCAN)
 256     {                           //FIXME : what is really use of RestartScan ?
 257       pCcb->StartEntry = pCcb->StartSector = 0;
 258     }
 259   // determine Buffer for result :
 260   if (Irp->MdlAddress)
 261     Buffer = MmGetSystemAddressForMdl (Irp->MdlAddress);
 262   else
 263     Buffer = Irp->UserBuffer;
 264   DPRINT ("Buffer=%x tofind=%S\n", Buffer, pSearchPattern->Buffer);
 265   if (pSearchPattern == NULL)
 266     {
 267       star[0] = '*';
 268       star[1] = 0;
 269       pCharPattern = star;
 270     }
 271   else
 272     pCharPattern = pSearchPattern->Buffer;
 273   tmpFcb.ObjectName = tmpFcb.PathName;
 274   while (RC == STATUS_SUCCESS && BufferLength > 0)
 275     {
 276       OldSector = pCcb->StartSector;
 277       OldEntry = pCcb->StartEntry;
 278       if (OldSector)
 279         pCcb->StartEntry++;
 280       RC =
 281         FindFile (DeviceExt, &tmpFcb, pFcb, pCharPattern, &pCcb->StartEntry, NULL);
 282     pCcb->StartSector = 1;
 283       DPRINT ("Found %S,RC=%x, sector %x entry %x\n", tmpFcb.ObjectName, RC,
 284               pCcb->StartSector, pCcb->StartEntry);
 285       if (NT_SUCCESS (RC))
 286         {
 287           switch (FileInformationClass)
 288             {
 289             case FileNameInformation:
 290               RC =
 291                 VfatGetFileNameInformation (&tmpFcb,
 292                                            (PFILE_NAMES_INFORMATION) Buffer,
 293                                            BufferLength);
 294               break;
 295             case FileDirectoryInformation:
 296               RC =
 297                 VfatGetFileDirectoryInformation (&tmpFcb, DeviceExt,
 298                                                 (PFILE_DIRECTORY_INFORMATION)
 299                                                 Buffer, BufferLength);
 300               break;
 301             case FileFullDirectoryInformation:
 302               RC =
 303                 VfatGetFileFullDirectoryInformation (&tmpFcb, DeviceExt,
 304                                                     (PFILE_FULL_DIRECTORY_INFORMATION)
 305                                                     Buffer, BufferLength);
 306               break;
 307             case FileBothDirectoryInformation:
 308               RC =
 309                 VfatGetFileBothInformation (&tmpFcb, DeviceExt,
 310                                            (PFILE_BOTH_DIRECTORY_INFORMATION)
 311                                            Buffer, BufferLength);
 312               break;
 313             default:
 314               RC = STATUS_INVALID_INFO_CLASS;
 315             }
 316         }
 317       else
 318         {
 319           if (Buffer0)
 320             Buffer0->NextEntryOffset = 0;
 321           break;
 322         }
 323       if (RC == STATUS_BUFFER_OVERFLOW)
 324         {
 325           if (Buffer0)
 326             Buffer0->NextEntryOffset = 0;
 327           pCcb->StartSector = OldSector;
 328           pCcb->StartEntry = OldEntry;
 329           break;
 330         }
 331       Buffer0 = (PFILE_NAMES_INFORMATION) Buffer;
 332       Buffer0->FileIndex = FileIndex++;
 333       if (Stack->Flags & SL_RETURN_SINGLE_ENTRY)
 334         break;
 335       BufferLength -= Buffer0->NextEntryOffset;
 336       Buffer += Buffer0->NextEntryOffset;
 337     }
 338   if (Buffer0)
 339     Buffer0->NextEntryOffset = 0;
 340   if (FileIndex > 0)
 341     return STATUS_SUCCESS;
 342   return RC;
 343 }
 344
 345
 346 NTSTATUS STDCALL
 347 VfatDirectoryControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
 348 /*
 349  * FUNCTION: directory control : read/write directory informations
 350  */
 351 {
 352   NTSTATUS RC = STATUS_SUCCESS;
 353   PFILE_OBJECT FileObject = NULL;
 354   PIO_STACK_LOCATION Stack;
 355   Stack = IoGetCurrentIrpStackLocation (Irp);
 356   CHECKPOINT;
 357   FileObject = Stack->FileObject;
 358   switch (Stack->MinorFunction)
 359     {
 360     case IRP_MN_QUERY_DIRECTORY:
 361       RC = DoQuery (DeviceObject, Irp, Stack);
 362       break;
 363     case IRP_MN_NOTIFY_CHANGE_DIRECTORY:
 364       DPRINT (" vfat, dir : change\n");
 365       RC = STATUS_NOT_IMPLEMENTED;
 366       break;
 367     default:
 368       // error
 369       DbgPrint ("unexpected minor function %x in VFAT driver\n",
 370                 Stack->MinorFunction);
 371       RC = STATUS_INVALID_DEVICE_REQUEST;
 372       break;
 373     }
 374   Irp->IoStatus.Status = RC;
 375   Irp->IoStatus.Information = 0;
 376
 377   IoCompleteRequest (Irp, IO_NO_INCREMENT);
 378   return RC;
 379 }
 380
 381