drivers/filesystems/ntfs/dirctl.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2002, 2003, 2014 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
  18  *
  19  * COPYRIGHT:        See COPYING in the top level directory
  20  * PROJECT:          ReactOS kernel
  21  * FILE:             drivers/filesystem/ntfs/dirctl.c
  22  * PURPOSE:          NTFS filesystem driver
  23  * PROGRAMMERS:      Eric Kohl
  24  *                   Pierre Schweitzer (pierre@reactos.org)
  25  *                   Hervé Poussineau (hpoussin@reactos.org)
  26  */
  27
  28 /* INCLUDES *****************************************************************/
  29
  30 #include "ntfs.h"
  31
  32 #define NDEBUG
  33 #include <debug.h>
  34
  35 /* FUNCTIONS ****************************************************************/
  36
  37 /**
  38 * @name NtfsAddFilenameToDirectory
  39 * @implemented
  40 *
  41 * Adds a $FILE_NAME attribute to a given directory index.
  42 *
  43 * @param DeviceExt
  44 * Points to the target disk's DEVICE_EXTENSION.
  45 *
  46 * @param DirectoryMftIndex
  47 * Mft index of the parent directory which will receive the file.
  48 *
  49 * @param FileReferenceNumber
  50 * File reference of the file to be added to the directory. This is a combination of the
  51 * Mft index and sequence number.
  52 *
  53 * @param FilenameAttribute
  54 * Pointer to the FILENAME_ATTRIBUTE of the file being added to the directory.
  55 *
  56 * @return
  57 * STATUS_SUCCESS on success.
  58 * STATUS_INSUFFICIENT_RESOURCES if an allocation fails.
  59 * STATUS_NOT_IMPLEMENTED if target address isn't at the end of the given file record.
  60 *
  61 * @remarks
  62 * WIP - Can only support an empty directory.
  63 * One FILENAME_ATTRIBUTE is added to the directory's index for each link to that file. So, each
  64 * file which contains one FILENAME_ATTRIBUTE for a long name and another for the 8.3 name, will
  65 * get both attributes added to its parent directory.
  66 */
  67 NTSTATUS
  68 NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt,
  69                            ULONGLONG DirectoryMftIndex,
  70                            ULONGLONG FileReferenceNumber,
  71                            PFILENAME_ATTRIBUTE FilenameAttribute)
  72 {
  73     NTSTATUS Status = STATUS_SUCCESS;
  74     PFILE_RECORD_HEADER ParentFileRecord;
  75     PNTFS_ATTR_CONTEXT IndexRootContext;
  76     PINDEX_ROOT_ATTRIBUTE I30IndexRoot;
  77     ULONG IndexRootOffset;
  78     ULONGLONG I30IndexRootLength;
  79     PINDEX_ENTRY_ATTRIBUTE IndexNodeEntry;
  80     ULONG LengthWritten;
  81     PNTFS_ATTR_RECORD DestinationAttribute;
  82     PINDEX_ROOT_ATTRIBUTE NewIndexRoot;
  83     ULONG AttributeLength;
  84     PNTFS_ATTR_RECORD NextAttribute;
  85
  86     // Allocate memory for the parent directory
  87     ParentFileRecord = ExAllocatePoolWithTag(NonPagedPool,
  88                                              DeviceExt->NtfsInfo.BytesPerFileRecord,
  89                                              TAG_NTFS);
  90     if (!ParentFileRecord)
  91     {
  92         DPRINT1("ERROR: Couldn't allocate memory for file record!\n");
  93         return STATUS_INSUFFICIENT_RESOURCES;
  94     }
  95
  96     // Open the parent directory
  97     Status = ReadFileRecord(DeviceExt, DirectoryMftIndex, ParentFileRecord);
  98     if (!NT_SUCCESS(Status))
  99     {
 100         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 101         DPRINT1("ERROR: Couldn't read parent directory with index %I64u\n",
 102                 DirectoryMftIndex);
 103         return Status;
 104     }
 105
 106     DPRINT1("Dumping old parent file record:\n");
 107     NtfsDumpFileRecord(DeviceExt, ParentFileRecord);
 108
 109     // Find the index root attribute for the directory
 110     Status = FindAttribute(DeviceExt,
 111                            ParentFileRecord,
 112                            AttributeIndexRoot,
 113                            L"$I30",
 114                            4,
 115                            &IndexRootContext,
 116                            &IndexRootOffset);
 117     if (!NT_SUCCESS(Status))
 118     {
 119         DPRINT1("ERROR: Couldn't find $I30 $INDEX_ROOT attribute for parent directory with MFT #: %I64u!\n",
 120                 DirectoryMftIndex);
 121         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 122         return Status;
 123     }
 124
 125     I30IndexRootLength = AttributeDataLength(&IndexRootContext->Record);
 126
 127     // Allocate memory for the index root data
 128     I30IndexRoot = (PINDEX_ROOT_ATTRIBUTE)ExAllocatePoolWithTag(NonPagedPool, I30IndexRootLength, TAG_NTFS);
 129     if (!I30IndexRoot)
 130     {
 131         DPRINT1("ERROR: Couldn't allocate memory for index root attribute!\n");
 132         ReleaseAttributeContext(IndexRootContext);
 133         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 134     }
 135
 136     // Read the Index Root
 137     Status = ReadAttribute(DeviceExt, IndexRootContext, 0, (PCHAR)I30IndexRoot, I30IndexRootLength);
 138     if (!NT_SUCCESS(Status))
 139     {
 140         DPRINT1("ERROR: Couln't read index root attribute for Mft index #%I64u\n", DirectoryMftIndex);
 141         ReleaseAttributeContext(IndexRootContext);
 142         ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 143         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 144         return Status;
 145     }
 146
 147     // Make sure it's empty (temporarily)
 148     IndexNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)I30IndexRoot + I30IndexRoot->Header.FirstEntryOffset + 0x10);
 149     if (IndexNodeEntry->Data.Directory.IndexedFile != 0 || IndexNodeEntry->Flags != 2)
 150     {
 151         DPRINT1("FIXME: File-creation is only supported in empty directories right now! Be patient! :)\n");
 152         ReleaseAttributeContext(IndexRootContext);
 153         ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 154         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 155         return STATUS_NOT_IMPLEMENTED;
 156     }
 157
 158     // Now we need to setup a new index root attribute to replace the old one
 159     NewIndexRoot = ExAllocatePoolWithTag(NonPagedPool, DeviceExt->NtfsInfo.BytesPerIndexRecord, TAG_NTFS);
 160     if (!NewIndexRoot)
 161     {
 162         DPRINT1("ERROR: Unable to allocate memory for new index root attribute!\n");
 163         ReleaseAttributeContext(IndexRootContext);
 164         ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 165         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 166         return STATUS_INSUFFICIENT_RESOURCES;
 167     }
 168
 169     // Setup the new index record
 170     RtlZeroMemory(NewIndexRoot, DeviceExt->NtfsInfo.BytesPerIndexRecord);   // shouldn't be necessary but aids in debugging
 171
 172     NewIndexRoot->AttributeType = AttributeFileName;
 173     NewIndexRoot->CollationRule = COLLATION_FILE_NAME;
 174     NewIndexRoot->SizeOfEntry = DeviceExt->NtfsInfo.BytesPerIndexRecord;
 175     // If Bytes per index record is less than cluster size, clusters per index record becomes sectors per index
 176     if(NewIndexRoot->SizeOfEntry < DeviceExt->NtfsInfo.BytesPerCluster)
 177         NewIndexRoot->ClustersPerIndexRecord = NewIndexRoot->SizeOfEntry / DeviceExt->NtfsInfo.BytesPerSector;
 178     else
 179         NewIndexRoot->ClustersPerIndexRecord = NewIndexRoot->SizeOfEntry / DeviceExt->NtfsInfo.BytesPerCluster;
 180
 181     // Setup the Index node header
 182     NewIndexRoot->Header.FirstEntryOffset = 0x10;
 183     NewIndexRoot->Header.Flags = INDEX_ROOT_SMALL;
 184     // still need to calculate sizes
 185
 186     // The first index node entry will be for the filename we're adding
 187     IndexNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)NewIndexRoot + NewIndexRoot->Header.FirstEntryOffset + 0x10);
 188     IndexNodeEntry->Data.Directory.IndexedFile = FileReferenceNumber;
 189     IndexNodeEntry->Flags = INDEX_ROOT_SMALL;
 190     IndexNodeEntry->KeyLength = FIELD_OFFSET(FILENAME_ATTRIBUTE, Name) + (2 * FilenameAttribute->NameLength);
 191     IndexNodeEntry->Length = ALIGN_UP_BY(IndexNodeEntry->KeyLength, 8) + FIELD_OFFSET(INDEX_ENTRY_ATTRIBUTE, FileName);
 192
 193     // Now we can calculate the Node length (temp logic)
 194     NewIndexRoot->Header.TotalSizeOfEntries = NewIndexRoot->Header.FirstEntryOffset + IndexNodeEntry->Length + 0x10;
 195     NewIndexRoot->Header.AllocatedSize = NewIndexRoot->Header.TotalSizeOfEntries;
 196
 197     DPRINT1("New Index Node Entry Stream Length: %u\nNew Inde Node Entry Length: %u\n",
 198             IndexNodeEntry->KeyLength,
 199             IndexNodeEntry->Length);
 200
 201     // copy over the attribute proper
 202     RtlCopyMemory(&IndexNodeEntry->FileName, FilenameAttribute, IndexNodeEntry->KeyLength);
 203
 204     // Now setup the dummy key
 205     IndexNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)IndexNodeEntry + IndexNodeEntry->Length);
 206
 207     IndexNodeEntry->Data.Directory.IndexedFile = 0;
 208     IndexNodeEntry->Length = 0x10;
 209     IndexNodeEntry->KeyLength = 0;
 210     IndexNodeEntry->Flags = NTFS_INDEX_ENTRY_END;
 211
 212     // This is when we'd normally setup the length (already done above)
 213
 214     // Write back the new index root attribute to the parent directory file record
 215
 216     // First, we need to make sure the attribute is large enough.
 217     // We can't set the size as we normally would, because if we extend past the file record,
 218     // we must create an index allocation and index bitmap (TODO). Also TODO: support file records with
 219     // $ATTRIBUTE_LIST's.
 220     AttributeLength = NewIndexRoot->Header.AllocatedSize + FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header);
 221     DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)ParentFileRecord + IndexRootOffset);
 222
 223     NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)DestinationAttribute + DestinationAttribute->Length);
 224     if (NextAttribute->Type != AttributeEnd)
 225     {
 226         DPRINT1("FIXME: For now, only resizing index root at the end of a file record is supported!\n");
 227         ExFreePoolWithTag(NewIndexRoot, TAG_NTFS);
 228         ReleaseAttributeContext(IndexRootContext);
 229         ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 230         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 231         return STATUS_NOT_IMPLEMENTED;
 232     }
 233
 234     // Update the length of the attribute in the file record of the parent directory
 235     InternalSetResidentAttributeLength(IndexRootContext,
 236                                        ParentFileRecord,
 237                                        IndexRootOffset,
 238                                        AttributeLength);
 239
 240     Status = UpdateFileRecord(DeviceExt, DirectoryMftIndex, ParentFileRecord);
 241     if (!NT_SUCCESS(Status))
 242     {
 243         DPRINT1("ERROR: Failed to update file record of directory with index: %llx\n", DirectoryMftIndex);
 244         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 245         ExFreePoolWithTag(NewIndexRoot, TAG_NTFS);
 246         ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 247         return Status;
 248     }
 249
 250     // Update the parent directory with the new index root
 251     Status = WriteAttribute(DeviceExt,
 252                             IndexRootContext,
 253                             0,
 254                             (PUCHAR)NewIndexRoot,
 255                             AttributeLength,
 256                             &LengthWritten);
 257     if (!NT_SUCCESS(Status) )
 258     {
 259         DPRINT1("ERROR: Unable to write new index root attribute to parent directory!\n");
 260         ExFreePoolWithTag(NewIndexRoot, TAG_NTFS);
 261         ReleaseAttributeContext(IndexRootContext);
 262         ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 263         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 264         return Status;
 265     }
 266
 267     // re-read the parent file record, so we can dump it
 268     Status = ReadFileRecord(DeviceExt, DirectoryMftIndex, ParentFileRecord);
 269     if (!NT_SUCCESS(Status))
 270     {
 271         DPRINT1("ERROR: Couldn't read parent directory after messing with it!\n");
 272     }
 273     else
 274     {
 275         DPRINT1("Dumping new parent file record:\n");
 276         NtfsDumpFileRecord(DeviceExt, ParentFileRecord);
 277     }
 278
 279     // Cleanup
 280     ExFreePoolWithTag(NewIndexRoot, TAG_NTFS);
 281     ReleaseAttributeContext(IndexRootContext);
 282     ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 283     ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 284
 285     return Status;
 286 }
 287
 288 ULONGLONG
 289 NtfsGetFileSize(PDEVICE_EXTENSION DeviceExt,
 290                 PFILE_RECORD_HEADER FileRecord,
 291                 PCWSTR Stream,
 292                 ULONG StreamLength,
 293                 PULONGLONG AllocatedSize)
 294 {
 295     ULONGLONG Size = 0ULL;
 296     ULONGLONG Allocated = 0ULL;
 297     NTSTATUS Status;
 298     PNTFS_ATTR_CONTEXT DataContext;
 299
 300     Status = FindAttribute(DeviceExt, FileRecord, AttributeData, Stream, StreamLength, &DataContext, NULL);
 301     if (NT_SUCCESS(Status))
 302     {
 303         Size = AttributeDataLength(&DataContext->Record);
 304         Allocated = AttributeAllocatedLength(&DataContext->Record);
 305         ReleaseAttributeContext(DataContext);
 306     }
 307
 308     if (AllocatedSize != NULL) *AllocatedSize = Allocated;
 309
 310     return Size;
 311 }
 312
 313
 314 static NTSTATUS
 315 NtfsGetNameInformation(PDEVICE_EXTENSION DeviceExt,
 316                        PFILE_RECORD_HEADER FileRecord,
 317                        ULONGLONG MFTIndex,
 318                        PFILE_NAMES_INFORMATION Info,
 319                        ULONG BufferLength)
 320 {
 321     ULONG Length;
 322     PFILENAME_ATTRIBUTE FileName;
 323
 324     DPRINT("NtfsGetNameInformation() called\n");
 325
 326     FileName = GetBestFileNameFromRecord(DeviceExt, FileRecord);
 327     if (FileName == NULL)
 328     {
 329         DPRINT1("No name information for file ID: %#I64x\n", MFTIndex);
 330         NtfsDumpFileAttributes(DeviceExt, FileRecord);
 331         return STATUS_OBJECT_NAME_NOT_FOUND;
 332     }
 333
 334     Length = FileName->NameLength * sizeof (WCHAR);
 335     if ((sizeof(FILE_NAMES_INFORMATION) + Length) > BufferLength)
 336         return(STATUS_BUFFER_OVERFLOW);
 337
 338     Info->FileNameLength = Length;
 339     Info->NextEntryOffset =
 340         ROUND_UP(sizeof(FILE_NAMES_INFORMATION) + Length, sizeof(ULONG));
 341     RtlCopyMemory(Info->FileName, FileName->Name, Length);
 342
 343     return(STATUS_SUCCESS);
 344 }
 345
 346
 347 static NTSTATUS
 348 NtfsGetDirectoryInformation(PDEVICE_EXTENSION DeviceExt,
 349                             PFILE_RECORD_HEADER FileRecord,
 350                             ULONGLONG MFTIndex,
 351                             PFILE_DIRECTORY_INFORMATION Info,
 352                             ULONG BufferLength)
 353 {
 354     ULONG Length;
 355     PFILENAME_ATTRIBUTE FileName;
 356     PSTANDARD_INFORMATION StdInfo;
 357
 358     DPRINT("NtfsGetDirectoryInformation() called\n");
 359
 360     FileName = GetBestFileNameFromRecord(DeviceExt, FileRecord);
 361     if (FileName == NULL)
 362     {
 363         DPRINT1("No name information for file ID: %#I64x\n", MFTIndex);
 364         NtfsDumpFileAttributes(DeviceExt, FileRecord);
 365         return STATUS_OBJECT_NAME_NOT_FOUND;
 366     }
 367
 368     StdInfo = GetStandardInformationFromRecord(DeviceExt, FileRecord);
 369     ASSERT(StdInfo != NULL);
 370
 371     Length = FileName->NameLength * sizeof (WCHAR);
 372     if ((sizeof(FILE_DIRECTORY_INFORMATION) + Length) > BufferLength)
 373         return(STATUS_BUFFER_OVERFLOW);
 374
 375     Info->FileNameLength = Length;
 376     Info->NextEntryOffset =
 377         ROUND_UP(sizeof(FILE_DIRECTORY_INFORMATION) + Length, sizeof(ULONG));
 378     RtlCopyMemory(Info->FileName, FileName->Name, Length);
 379
 380     Info->CreationTime.QuadPart = FileName->CreationTime;
 381     Info->LastAccessTime.QuadPart = FileName->LastAccessTime;
 382     Info->LastWriteTime.QuadPart = FileName->LastWriteTime;
 383     Info->ChangeTime.QuadPart = FileName->ChangeTime;
 384
 385     /* Convert file flags */
 386     NtfsFileFlagsToAttributes(FileName->FileAttributes | StdInfo->FileAttribute, &Info->FileAttributes);
 387
 388     Info->EndOfFile.QuadPart = NtfsGetFileSize(DeviceExt, FileRecord, L"", 0, (PULONGLONG)&Info->AllocationSize.QuadPart);
 389
 390     Info->FileIndex = MFTIndex;
 391
 392     return STATUS_SUCCESS;
 393 }
 394
 395
 396 static NTSTATUS
 397 NtfsGetFullDirectoryInformation(PDEVICE_EXTENSION DeviceExt,
 398                                 PFILE_RECORD_HEADER FileRecord,
 399                                 ULONGLONG MFTIndex,
 400                                 PFILE_FULL_DIRECTORY_INFORMATION Info,
 401                                 ULONG BufferLength)
 402 {
 403     ULONG Length;
 404     PFILENAME_ATTRIBUTE FileName;
 405     PSTANDARD_INFORMATION StdInfo;
 406
 407     DPRINT("NtfsGetFullDirectoryInformation() called\n");
 408
 409     FileName = GetBestFileNameFromRecord(DeviceExt, FileRecord);
 410     if (FileName == NULL)
 411     {
 412         DPRINT1("No name information for file ID: %#I64x\n", MFTIndex);
 413         NtfsDumpFileAttributes(DeviceExt, FileRecord);
 414         return STATUS_OBJECT_NAME_NOT_FOUND;
 415     }
 416
 417     StdInfo = GetStandardInformationFromRecord(DeviceExt, FileRecord);
 418     ASSERT(StdInfo != NULL);
 419
 420     Length = FileName->NameLength * sizeof (WCHAR);
 421     if ((sizeof(FILE_FULL_DIRECTORY_INFORMATION) + Length) > BufferLength)
 422         return(STATUS_BUFFER_OVERFLOW);
 423
 424     Info->FileNameLength = Length;
 425     Info->NextEntryOffset =
 426         ROUND_UP(sizeof(FILE_FULL_DIRECTORY_INFORMATION) + Length, sizeof(ULONG));
 427     RtlCopyMemory(Info->FileName, FileName->Name, Length);
 428
 429     Info->CreationTime.QuadPart = FileName->CreationTime;
 430     Info->LastAccessTime.QuadPart = FileName->LastAccessTime;
 431     Info->LastWriteTime.QuadPart = FileName->LastWriteTime;
 432     Info->ChangeTime.QuadPart = FileName->ChangeTime;
 433
 434     /* Convert file flags */
 435     NtfsFileFlagsToAttributes(FileName->FileAttributes | StdInfo->FileAttribute, &Info->FileAttributes);
 436
 437     Info->EndOfFile.QuadPart = NtfsGetFileSize(DeviceExt, FileRecord, L"", 0, (PULONGLONG)&Info->AllocationSize.QuadPart);
 438
 439     Info->FileIndex = MFTIndex;
 440     Info->EaSize = 0;
 441
 442     return STATUS_SUCCESS;
 443 }
 444
 445
 446 static NTSTATUS
 447 NtfsGetBothDirectoryInformation(PDEVICE_EXTENSION DeviceExt,
 448                                 PFILE_RECORD_HEADER FileRecord,
 449                                 ULONGLONG MFTIndex,
 450                                 PFILE_BOTH_DIR_INFORMATION Info,
 451                                 ULONG BufferLength)
 452 {
 453     ULONG Length;
 454     PFILENAME_ATTRIBUTE FileName, ShortFileName;
 455     PSTANDARD_INFORMATION StdInfo;
 456
 457     DPRINT("NtfsGetBothDirectoryInformation() called\n");
 458
 459     FileName = GetBestFileNameFromRecord(DeviceExt, FileRecord);
 460     if (FileName == NULL)
 461     {
 462         DPRINT1("No name information for file ID: %#I64x\n", MFTIndex);
 463         NtfsDumpFileAttributes(DeviceExt, FileRecord);
 464         return STATUS_OBJECT_NAME_NOT_FOUND;
 465     }
 466     ShortFileName = GetFileNameFromRecord(DeviceExt, FileRecord, NTFS_FILE_NAME_DOS);
 467
 468     StdInfo = GetStandardInformationFromRecord(DeviceExt, FileRecord);
 469     ASSERT(StdInfo != NULL);
 470
 471     Length = FileName->NameLength * sizeof (WCHAR);
 472     if ((sizeof(FILE_BOTH_DIR_INFORMATION) + Length) > BufferLength)
 473         return(STATUS_BUFFER_OVERFLOW);
 474
 475     Info->FileNameLength = Length;
 476     Info->NextEntryOffset =
 477         ROUND_UP(sizeof(FILE_BOTH_DIR_INFORMATION) + Length, sizeof(ULONG));
 478     RtlCopyMemory(Info->FileName, FileName->Name, Length);
 479
 480     if (ShortFileName)
 481     {
 482         /* Should we upcase the filename? */
 483         ASSERT(ShortFileName->NameLength <= ARRAYSIZE(Info->ShortName));
 484         Info->ShortNameLength = ShortFileName->NameLength * sizeof(WCHAR);
 485         RtlCopyMemory(Info->ShortName, ShortFileName->Name, Info->ShortNameLength);
 486     }
 487     else
 488     {
 489         Info->ShortName[0] = 0;
 490         Info->ShortNameLength = 0;
 491     }
 492
 493     Info->CreationTime.QuadPart = FileName->CreationTime;
 494     Info->LastAccessTime.QuadPart = FileName->LastAccessTime;
 495     Info->LastWriteTime.QuadPart = FileName->LastWriteTime;
 496     Info->ChangeTime.QuadPart = FileName->ChangeTime;
 497
 498     /* Convert file flags */
 499     NtfsFileFlagsToAttributes(FileName->FileAttributes | StdInfo->FileAttribute, &Info->FileAttributes);
 500
 501     Info->EndOfFile.QuadPart = NtfsGetFileSize(DeviceExt, FileRecord, L"", 0, (PULONGLONG)&Info->AllocationSize.QuadPart);
 502
 503     Info->FileIndex = MFTIndex;
 504     Info->EaSize = 0;
 505
 506     return STATUS_SUCCESS;
 507 }
 508
 509
 510 NTSTATUS
 511 NtfsQueryDirectory(PNTFS_IRP_CONTEXT IrpContext)
 512 {
 513     PIRP Irp;
 514     PDEVICE_OBJECT DeviceObject;
 515     PDEVICE_EXTENSION DeviceExtension;
 516     LONG BufferLength = 0;
 517     PUNICODE_STRING SearchPattern = NULL;
 518     FILE_INFORMATION_CLASS FileInformationClass;
 519     ULONG FileIndex = 0;
 520     PUCHAR Buffer = NULL;
 521     PFILE_NAMES_INFORMATION Buffer0 = NULL;
 522     PNTFS_FCB Fcb;
 523     PNTFS_CCB Ccb;
 524     BOOLEAN First = FALSE;
 525     PIO_STACK_LOCATION Stack;
 526     PFILE_OBJECT FileObject;
 527     NTSTATUS Status = STATUS_SUCCESS;
 528     PFILE_RECORD_HEADER FileRecord;
 529     ULONGLONG MFTRecord, OldMFTRecord = 0;
 530     UNICODE_STRING Pattern;
 531
 532     DPRINT1("NtfsQueryDirectory() called\n");
 533
 534     ASSERT(IrpContext);
 535     Irp = IrpContext->Irp;
 536     DeviceObject = IrpContext->DeviceObject;
 537
 538     DeviceExtension = DeviceObject->DeviceExtension;
 539     Stack = IoGetCurrentIrpStackLocation(Irp);
 540     FileObject = Stack->FileObject;
 541
 542     Ccb = (PNTFS_CCB)FileObject->FsContext2;
 543     Fcb = (PNTFS_FCB)FileObject->FsContext;
 544
 545     /* Obtain the callers parameters */
 546     BufferLength = Stack->Parameters.QueryDirectory.Length;
 547     SearchPattern = Stack->Parameters.QueryDirectory.FileName;
 548     FileInformationClass = Stack->Parameters.QueryDirectory.FileInformationClass;
 549     FileIndex = Stack->Parameters.QueryDirectory.FileIndex;
 550
 551     if (NtfsFCBIsCompressed(Fcb))
 552     {
 553         DPRINT1("Compressed directory!\n");
 554         UNIMPLEMENTED;
 555         return STATUS_NOT_IMPLEMENTED;
 556     }
 557
 558     if (!ExAcquireResourceSharedLite(&Fcb->MainResource,
 559                                      BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT)))
 560     {
 561         return STATUS_PENDING;
 562     }
 563
 564     if (SearchPattern != NULL)
 565     {
 566         if (!Ccb->DirectorySearchPattern)
 567         {
 568             First = TRUE;
 569             Pattern.Length = 0;
 570             Pattern.MaximumLength = SearchPattern->Length + sizeof(WCHAR);
 571             Ccb->DirectorySearchPattern = Pattern.Buffer =
 572                 ExAllocatePoolWithTag(NonPagedPool, Pattern.MaximumLength, TAG_NTFS);
 573             if (!Ccb->DirectorySearchPattern)
 574             {
 575                 ExReleaseResourceLite(&Fcb->MainResource);
 576                 return STATUS_INSUFFICIENT_RESOURCES;
 577             }
 578
 579             memcpy(Ccb->DirectorySearchPattern, SearchPattern->Buffer, SearchPattern->Length);
 580             Ccb->DirectorySearchPattern[SearchPattern->Length / sizeof(WCHAR)] = 0;
 581         }
 582     }
 583     else if (!Ccb->DirectorySearchPattern)
 584     {
 585         First = TRUE;
 586         Ccb->DirectorySearchPattern = ExAllocatePoolWithTag(NonPagedPool, 2 * sizeof(WCHAR), TAG_NTFS);
 587         if (!Ccb->DirectorySearchPattern)
 588         {
 589             ExReleaseResourceLite(&Fcb->MainResource);
 590             return STATUS_INSUFFICIENT_RESOURCES;
 591         }
 592
 593         Ccb->DirectorySearchPattern[0] = L'*';
 594         Ccb->DirectorySearchPattern[1] = 0;
 595     }
 596
 597     RtlInitUnicodeString(&Pattern, Ccb->DirectorySearchPattern);
 598     DPRINT("Search pattern '%S'\n", Ccb->DirectorySearchPattern);
 599     DPRINT("In: '%S'\n", Fcb->PathName);
 600
 601     /* Determine directory index */
 602     if (Stack->Flags & SL_INDEX_SPECIFIED)
 603     {
 604         Ccb->Entry = Ccb->CurrentByteOffset.u.LowPart;
 605     }
 606     else if (First || (Stack->Flags & SL_RESTART_SCAN))
 607     {
 608         Ccb->Entry = 0;
 609     }
 610
 611     /* Get Buffer for result */
 612     Buffer = NtfsGetUserBuffer(Irp, FALSE);
 613
 614     DPRINT("Buffer=%p tofind=%S\n", Buffer, Ccb->DirectorySearchPattern);
 615
 616     if (!ExAcquireResourceExclusiveLite(&DeviceExtension->DirResource,
 617                                         BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT)))
 618     {
 619         ExReleaseResourceLite(&Fcb->MainResource);
 620         return STATUS_PENDING;
 621     }
 622
 623     while (Status == STATUS_SUCCESS && BufferLength > 0)
 624     {
 625         Status = NtfsFindFileAt(DeviceExtension,
 626                                 &Pattern,
 627                                 &Ccb->Entry,
 628                                 &FileRecord,
 629                                 &MFTRecord,
 630                                 Fcb->MFTIndex,
 631                                 (Stack->Flags & SL_CASE_SENSITIVE));
 632
 633         if (NT_SUCCESS(Status))
 634         {
 635             /* HACK: files with both a short name and a long name are present twice in the index.
 636              * Ignore the second entry, if it is immediately following the first one.
 637              */
 638             if (MFTRecord == OldMFTRecord)
 639             {
 640                 DPRINT1("Ignoring duplicate MFT entry 0x%x\n", MFTRecord);
 641                 Ccb->Entry++;
 642                 ExFreePoolWithTag(FileRecord, TAG_NTFS);
 643                 continue;
 644             }
 645             OldMFTRecord = MFTRecord;
 646
 647             switch (FileInformationClass)
 648             {
 649                 case FileNameInformation:
 650                     Status = NtfsGetNameInformation(DeviceExtension,
 651                                                     FileRecord,
 652                                                     MFTRecord,
 653                                                     (PFILE_NAMES_INFORMATION)Buffer,
 654                                                     BufferLength);
 655                     break;
 656
 657                 case FileDirectoryInformation:
 658                     Status = NtfsGetDirectoryInformation(DeviceExtension,
 659                                                          FileRecord,
 660                                                          MFTRecord,
 661                                                          (PFILE_DIRECTORY_INFORMATION)Buffer,
 662                                                          BufferLength);
 663                     break;
 664
 665                 case FileFullDirectoryInformation:
 666                     Status = NtfsGetFullDirectoryInformation(DeviceExtension,
 667                                                              FileRecord,
 668                                                              MFTRecord,
 669                                                              (PFILE_FULL_DIRECTORY_INFORMATION)Buffer,
 670                                                              BufferLength);
 671                     break;
 672
 673                 case FileBothDirectoryInformation:
 674                     Status = NtfsGetBothDirectoryInformation(DeviceExtension,
 675                                                              FileRecord,
 676                                                              MFTRecord,
 677                                                              (PFILE_BOTH_DIR_INFORMATION)Buffer,
 678                                                              BufferLength);
 679                     break;
 680
 681                 default:
 682                     Status = STATUS_INVALID_INFO_CLASS;
 683             }
 684
 685             if (Status == STATUS_BUFFER_OVERFLOW)
 686             {
 687                 if (Buffer0)
 688                 {
 689                     Buffer0->NextEntryOffset = 0;
 690                 }
 691                 break;
 692             }
 693         }
 694         else
 695         {
 696             if (Buffer0)
 697             {
 698                 Buffer0->NextEntryOffset = 0;
 699             }
 700
 701             if (First)
 702             {
 703                 Status = STATUS_NO_SUCH_FILE;
 704             }
 705             else
 706             {
 707                 Status = STATUS_NO_MORE_FILES;
 708             }
 709             break;
 710         }
 711
 712         Buffer0 = (PFILE_NAMES_INFORMATION)Buffer;
 713         Buffer0->FileIndex = FileIndex++;
 714         Ccb->Entry++;
 715
 716         if (Stack->Flags & SL_RETURN_SINGLE_ENTRY)
 717         {
 718             break;
 719         }
 720         BufferLength -= Buffer0->NextEntryOffset;
 721         Buffer += Buffer0->NextEntryOffset;
 722         ExFreePoolWithTag(FileRecord, TAG_NTFS);
 723     }
 724
 725     if (Buffer0)
 726     {
 727         Buffer0->NextEntryOffset = 0;
 728     }
 729
 730     ExReleaseResourceLite(&DeviceExtension->DirResource);
 731     ExReleaseResourceLite(&Fcb->MainResource);
 732
 733     if (FileIndex > 0)
 734     {
 735         Status = STATUS_SUCCESS;
 736     }
 737
 738     return Status;
 739 }
 740
 741
 742 NTSTATUS
 743 NtfsDirectoryControl(PNTFS_IRP_CONTEXT IrpContext)
 744 {
 745     NTSTATUS Status = STATUS_UNSUCCESSFUL;
 746
 747     DPRINT1("NtfsDirectoryControl() called\n");
 748
 749     switch (IrpContext->MinorFunction)
 750     {
 751         case IRP_MN_QUERY_DIRECTORY:
 752             Status = NtfsQueryDirectory(IrpContext);
 753             break;
 754
 755         case IRP_MN_NOTIFY_CHANGE_DIRECTORY:
 756             DPRINT1("IRP_MN_NOTIFY_CHANGE_DIRECTORY\n");
 757             Status = STATUS_NOT_IMPLEMENTED;
 758             break;
 759
 760         default:
 761             Status = STATUS_INVALID_DEVICE_REQUEST;
 762             break;
 763     }
 764
 765     if (Status == STATUS_PENDING && IrpContext->Flags & IRPCONTEXT_COMPLETE)
 766     {
 767         return NtfsMarkIrpContextForQueue(IrpContext);
 768     }
 769
 770     IrpContext->Irp->IoStatus.Information = 0;
 771
 772     return Status;
 773 }
 774
 775 /* EOF */