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 * @param CaseSensitive
  57 * Boolean indicating if the function should operate in case-sensitive mode. This will be TRUE
  58 * if an application created the file with the FILE_FLAG_POSIX_SEMANTICS flag.
  59 *
  60 * @return
  61 * STATUS_SUCCESS on success.
  62 * STATUS_INSUFFICIENT_RESOURCES if an allocation fails.
  63 * STATUS_NOT_IMPLEMENTED if target address isn't at the end of the given file record.
  64 *
  65 * @remarks
  66 * WIP - Can only support a few files in a directory.
  67 * One FILENAME_ATTRIBUTE is added to the directory's index for each link to that file. So, each
  68 * file which contains one FILENAME_ATTRIBUTE for a long name and another for the 8.3 name, will
  69 * get both attributes added to its parent directory.
  70 */
  71 NTSTATUS
  72 NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt,
  73                            ULONGLONG DirectoryMftIndex,
  74                            ULONGLONG FileReferenceNumber,
  75                            PFILENAME_ATTRIBUTE FilenameAttribute,
  76                            BOOLEAN CaseSensitive)
  77 {
  78     NTSTATUS Status = STATUS_SUCCESS;
  79     PFILE_RECORD_HEADER ParentFileRecord;
  80     PNTFS_ATTR_CONTEXT IndexRootContext;
  81     PINDEX_ROOT_ATTRIBUTE I30IndexRoot;
  82     ULONG IndexRootOffset;
  83     ULONGLONG I30IndexRootLength;
  84     ULONG LengthWritten;
  85     PNTFS_ATTR_RECORD DestinationAttribute;
  86     PINDEX_ROOT_ATTRIBUTE NewIndexRoot;
  87     ULONG AttributeLength;
  88     PNTFS_ATTR_RECORD NextAttribute;
  89     PB_TREE NewTree;
  90     ULONG BtreeIndexLength;
  91     ULONG MaxIndexSize;
  92
  93     // Allocate memory for the parent directory
  94     ParentFileRecord = ExAllocatePoolWithTag(NonPagedPool,
  95                                              DeviceExt->NtfsInfo.BytesPerFileRecord,
  96                                              TAG_NTFS);
  97     if (!ParentFileRecord)
  98     {
  99         DPRINT1("ERROR: Couldn't allocate memory for file record!\n");
 100         return STATUS_INSUFFICIENT_RESOURCES;
 101     }
 102
 103     // Open the parent directory
 104     Status = ReadFileRecord(DeviceExt, DirectoryMftIndex, ParentFileRecord);
 105     if (!NT_SUCCESS(Status))
 106     {
 107         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 108         DPRINT1("ERROR: Couldn't read parent directory with index %I64u\n",
 109                 DirectoryMftIndex);
 110         return Status;
 111     }
 112
 113     DPRINT1("Dumping old parent file record:\n");
 114     NtfsDumpFileRecord(DeviceExt, ParentFileRecord);
 115
 116     // Find the index root attribute for the directory
 117     Status = FindAttribute(DeviceExt,
 118                            ParentFileRecord,
 119                            AttributeIndexRoot,
 120                            L"$I30",
 121                            4,
 122                            &IndexRootContext,
 123                            &IndexRootOffset);
 124     if (!NT_SUCCESS(Status))
 125     {
 126         DPRINT1("ERROR: Couldn't find $I30 $INDEX_ROOT attribute for parent directory with MFT #: %I64u!\n",
 127                 DirectoryMftIndex);
 128         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 129         return Status;
 130     }
 131
 132     // Find the maximum index size given what the file record can hold
 133     MaxIndexSize = DeviceExt->NtfsInfo.BytesPerFileRecord
 134                    - IndexRootOffset
 135                    - IndexRootContext->Record.Resident.ValueOffset
 136                    - FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header)
 137                    - (sizeof(ULONG) * 2);
 138
 139     // Allocate memory for the index root data
 140     I30IndexRootLength = AttributeDataLength(&IndexRootContext->Record);
 141     I30IndexRoot = ExAllocatePoolWithTag(NonPagedPool, I30IndexRootLength, TAG_NTFS);
 142     if (!I30IndexRoot)
 143     {
 144         DPRINT1("ERROR: Couldn't allocate memory for index root attribute!\n");
 145         ReleaseAttributeContext(IndexRootContext);
 146         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 147         return STATUS_INSUFFICIENT_RESOURCES;
 148     }
 149
 150     // Read the Index Root
 151     Status = ReadAttribute(DeviceExt, IndexRootContext, 0, (PCHAR)I30IndexRoot, I30IndexRootLength);
 152     if (!NT_SUCCESS(Status))
 153     {
 154         DPRINT1("ERROR: Couln't read index root attribute for Mft index #%I64u\n", DirectoryMftIndex);
 155         ReleaseAttributeContext(IndexRootContext);
 156         ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 157         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 158         return Status;
 159     }
 160
 161     // Convert the index to a B*Tree
 162     Status = CreateBTreeFromIndex(IndexRootContext, I30IndexRoot, &NewTree);
 163     if (!NT_SUCCESS(Status))
 164     {
 165         DPRINT1("ERROR: Failed to create B-Tree from Index!\n");
 166         ReleaseAttributeContext(IndexRootContext);
 167         ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 168         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 169         return Status;
 170     }
 171
 172     DumpBTree(NewTree);
 173
 174     // Insert the key for the file we're adding
 175     Status = NtfsInsertKey(FileReferenceNumber, FilenameAttribute, NewTree->RootNode, CaseSensitive);
 176     if (!NT_SUCCESS(Status))
 177     {
 178         DPRINT1("ERROR: Failed to insert key into B-Tree!\n");
 179         DestroyBTree(NewTree);
 180         ReleaseAttributeContext(IndexRootContext);
 181         ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 182         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 183         return Status;
 184     }
 185
 186     DumpBTree(NewTree);
 187
 188     // Convert B*Tree back to Index Root
 189     Status = CreateIndexRootFromBTree(DeviceExt, NewTree, MaxIndexSize, &NewIndexRoot, &BtreeIndexLength);
 190     if (!NT_SUCCESS(Status))
 191     {
 192         DPRINT1("ERROR: Failed to create Index root from B-Tree!\n");
 193         DestroyBTree(NewTree);
 194         ReleaseAttributeContext(IndexRootContext);
 195         ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 196         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 197         return Status;
 198     }
 199
 200     // We're done with the B-Tree now
 201     DestroyBTree(NewTree);
 202
 203     // Write back the new index root attribute to the parent directory file record
 204
 205     // First, we need to resize the attribute.
 206     // CreateIndexRootFromBTree() should have verified that the index root fits within MaxIndexSize.
 207     // We can't set the size as we normally would, because if we extend past the file record,
 208     // we must create an index allocation and index bitmap (TODO). Also TODO: support file records with
 209     // $ATTRIBUTE_LIST's.
 210     AttributeLength = NewIndexRoot->Header.AllocatedSize + FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header);
 211     DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)ParentFileRecord + IndexRootOffset);
 212
 213     // Find the attribute (or attribute-end marker) after the index root
 214     NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)DestinationAttribute + DestinationAttribute->Length);
 215     if (NextAttribute->Type != AttributeEnd)
 216     {
 217         DPRINT1("FIXME: For now, only resizing index root at the end of a file record is supported!\n");
 218         ExFreePoolWithTag(NewIndexRoot, TAG_NTFS);
 219         ReleaseAttributeContext(IndexRootContext);
 220         ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 221         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 222         return STATUS_NOT_IMPLEMENTED;
 223     }
 224
 225     // Update the length of the attribute in the file record of the parent directory
 226     InternalSetResidentAttributeLength(IndexRootContext,
 227                                        ParentFileRecord,
 228                                        IndexRootOffset,
 229                                        AttributeLength);
 230
 231     NT_ASSERT(ParentFileRecord->BytesInUse <= DeviceExt->NtfsInfo.BytesPerFileRecord);
 232
 233     Status = UpdateFileRecord(DeviceExt, DirectoryMftIndex, ParentFileRecord);
 234     if (!NT_SUCCESS(Status))
 235     {
 236         DPRINT1("ERROR: Failed to update file record of directory with index: %llx\n", DirectoryMftIndex);
 237         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 238         ExFreePoolWithTag(NewIndexRoot, TAG_NTFS);
 239         ReleaseAttributeContext(IndexRootContext);
 240         ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 241         return Status;
 242     }
 243
 244     // Write the new index root to disk
 245     Status = WriteAttribute(DeviceExt,
 246                             IndexRootContext,
 247                             0,
 248                             (PUCHAR)NewIndexRoot,
 249                             AttributeLength,
 250                             &LengthWritten);
 251     if (!NT_SUCCESS(Status) )
 252     {
 253         DPRINT1("ERROR: Unable to write new index root attribute to parent directory!\n");
 254         ExFreePoolWithTag(NewIndexRoot, TAG_NTFS);
 255         ReleaseAttributeContext(IndexRootContext);
 256         ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 257         ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 258         return Status;
 259     }
 260
 261     // re-read the parent file record, so we can dump it
 262     Status = ReadFileRecord(DeviceExt, DirectoryMftIndex, ParentFileRecord);
 263     if (!NT_SUCCESS(Status))
 264     {
 265         DPRINT1("ERROR: Couldn't read parent directory after messing with it!\n");
 266     }
 267     else
 268     {
 269         DPRINT1("Dumping new parent file record:\n");
 270         NtfsDumpFileRecord(DeviceExt, ParentFileRecord);
 271     }
 272
 273     // Cleanup
 274     ExFreePoolWithTag(NewIndexRoot, TAG_NTFS);
 275     ReleaseAttributeContext(IndexRootContext);
 276     ExFreePoolWithTag(I30IndexRoot, TAG_NTFS);
 277     ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);
 278
 279     return Status;
 280 }
 281
 282 ULONGLONG
 283 NtfsGetFileSize(PDEVICE_EXTENSION DeviceExt,
 284                 PFILE_RECORD_HEADER FileRecord,
 285                 PCWSTR Stream,
 286                 ULONG StreamLength,
 287                 PULONGLONG AllocatedSize)
 288 {
 289     ULONGLONG Size = 0ULL;
 290     ULONGLONG Allocated = 0ULL;
 291     NTSTATUS Status;
 292     PNTFS_ATTR_CONTEXT DataContext;
 293
 294     Status = FindAttribute(DeviceExt, FileRecord, AttributeData, Stream, StreamLength, &DataContext, NULL);
 295     if (NT_SUCCESS(Status))
 296     {
 297         Size = AttributeDataLength(&DataContext->Record);
 298         Allocated = AttributeAllocatedLength(&DataContext->Record);
 299         ReleaseAttributeContext(DataContext);
 300     }
 301
 302     if (AllocatedSize != NULL) *AllocatedSize = Allocated;
 303
 304     return Size;
 305 }
 306
 307
 308 static NTSTATUS
 309 NtfsGetNameInformation(PDEVICE_EXTENSION DeviceExt,
 310                        PFILE_RECORD_HEADER FileRecord,
 311                        ULONGLONG MFTIndex,
 312                        PFILE_NAMES_INFORMATION Info,
 313                        ULONG BufferLength)
 314 {
 315     ULONG Length;
 316     PFILENAME_ATTRIBUTE FileName;
 317
 318     DPRINT("NtfsGetNameInformation() called\n");
 319
 320     FileName = GetBestFileNameFromRecord(DeviceExt, FileRecord);
 321     if (FileName == NULL)
 322     {
 323         DPRINT1("No name information for file ID: %#I64x\n", MFTIndex);
 324         NtfsDumpFileAttributes(DeviceExt, FileRecord);
 325         return STATUS_OBJECT_NAME_NOT_FOUND;
 326     }
 327
 328     Length = FileName->NameLength * sizeof (WCHAR);
 329     if ((sizeof(FILE_NAMES_INFORMATION) + Length) > BufferLength)
 330         return(STATUS_BUFFER_OVERFLOW);
 331
 332     Info->FileNameLength = Length;
 333     Info->NextEntryOffset =
 334         ROUND_UP(sizeof(FILE_NAMES_INFORMATION) + Length, sizeof(ULONG));
 335     RtlCopyMemory(Info->FileName, FileName->Name, Length);
 336
 337     return(STATUS_SUCCESS);
 338 }
 339
 340
 341 static NTSTATUS
 342 NtfsGetDirectoryInformation(PDEVICE_EXTENSION DeviceExt,
 343                             PFILE_RECORD_HEADER FileRecord,
 344                             ULONGLONG MFTIndex,
 345                             PFILE_DIRECTORY_INFORMATION Info,
 346                             ULONG BufferLength)
 347 {
 348     ULONG Length;
 349     PFILENAME_ATTRIBUTE FileName;
 350     PSTANDARD_INFORMATION StdInfo;
 351
 352     DPRINT("NtfsGetDirectoryInformation() called\n");
 353
 354     FileName = GetBestFileNameFromRecord(DeviceExt, FileRecord);
 355     if (FileName == NULL)
 356     {
 357         DPRINT1("No name information for file ID: %#I64x\n", MFTIndex);
 358         NtfsDumpFileAttributes(DeviceExt, FileRecord);
 359         return STATUS_OBJECT_NAME_NOT_FOUND;
 360     }
 361
 362     StdInfo = GetStandardInformationFromRecord(DeviceExt, FileRecord);
 363     ASSERT(StdInfo != NULL);
 364
 365     Length = FileName->NameLength * sizeof (WCHAR);
 366     if ((sizeof(FILE_DIRECTORY_INFORMATION) + Length) > BufferLength)
 367         return(STATUS_BUFFER_OVERFLOW);
 368
 369     Info->FileNameLength = Length;
 370     Info->NextEntryOffset =
 371         ROUND_UP(sizeof(FILE_DIRECTORY_INFORMATION) + Length, sizeof(ULONG));
 372     RtlCopyMemory(Info->FileName, FileName->Name, Length);
 373
 374     Info->CreationTime.QuadPart = FileName->CreationTime;
 375     Info->LastAccessTime.QuadPart = FileName->LastAccessTime;
 376     Info->LastWriteTime.QuadPart = FileName->LastWriteTime;
 377     Info->ChangeTime.QuadPart = FileName->ChangeTime;
 378
 379     /* Convert file flags */
 380     NtfsFileFlagsToAttributes(FileName->FileAttributes | StdInfo->FileAttribute, &Info->FileAttributes);
 381
 382     Info->EndOfFile.QuadPart = NtfsGetFileSize(DeviceExt, FileRecord, L"", 0, (PULONGLONG)&Info->AllocationSize.QuadPart);
 383
 384     Info->FileIndex = MFTIndex;
 385
 386     return STATUS_SUCCESS;
 387 }
 388
 389
 390 static NTSTATUS
 391 NtfsGetFullDirectoryInformation(PDEVICE_EXTENSION DeviceExt,
 392                                 PFILE_RECORD_HEADER FileRecord,
 393                                 ULONGLONG MFTIndex,
 394                                 PFILE_FULL_DIRECTORY_INFORMATION Info,
 395                                 ULONG BufferLength)
 396 {
 397     ULONG Length;
 398     PFILENAME_ATTRIBUTE FileName;
 399     PSTANDARD_INFORMATION StdInfo;
 400
 401     DPRINT("NtfsGetFullDirectoryInformation() called\n");
 402
 403     FileName = GetBestFileNameFromRecord(DeviceExt, FileRecord);
 404     if (FileName == NULL)
 405     {
 406         DPRINT1("No name information for file ID: %#I64x\n", MFTIndex);
 407         NtfsDumpFileAttributes(DeviceExt, FileRecord);
 408         return STATUS_OBJECT_NAME_NOT_FOUND;
 409     }
 410
 411     StdInfo = GetStandardInformationFromRecord(DeviceExt, FileRecord);
 412     ASSERT(StdInfo != NULL);
 413
 414     Length = FileName->NameLength * sizeof (WCHAR);
 415     if ((sizeof(FILE_FULL_DIRECTORY_INFORMATION) + Length) > BufferLength)
 416         return(STATUS_BUFFER_OVERFLOW);
 417
 418     Info->FileNameLength = Length;
 419     Info->NextEntryOffset =
 420         ROUND_UP(sizeof(FILE_FULL_DIRECTORY_INFORMATION) + Length, sizeof(ULONG));
 421     RtlCopyMemory(Info->FileName, FileName->Name, Length);
 422
 423     Info->CreationTime.QuadPart = FileName->CreationTime;
 424     Info->LastAccessTime.QuadPart = FileName->LastAccessTime;
 425     Info->LastWriteTime.QuadPart = FileName->LastWriteTime;
 426     Info->ChangeTime.QuadPart = FileName->ChangeTime;
 427
 428     /* Convert file flags */
 429     NtfsFileFlagsToAttributes(FileName->FileAttributes | StdInfo->FileAttribute, &Info->FileAttributes);
 430
 431     Info->EndOfFile.QuadPart = NtfsGetFileSize(DeviceExt, FileRecord, L"", 0, (PULONGLONG)&Info->AllocationSize.QuadPart);
 432
 433     Info->FileIndex = MFTIndex;
 434     Info->EaSize = 0;
 435
 436     return STATUS_SUCCESS;
 437 }
 438
 439
 440 static NTSTATUS
 441 NtfsGetBothDirectoryInformation(PDEVICE_EXTENSION DeviceExt,
 442                                 PFILE_RECORD_HEADER FileRecord,
 443                                 ULONGLONG MFTIndex,
 444                                 PFILE_BOTH_DIR_INFORMATION Info,
 445                                 ULONG BufferLength)
 446 {
 447     ULONG Length;
 448     PFILENAME_ATTRIBUTE FileName, ShortFileName;
 449     PSTANDARD_INFORMATION StdInfo;
 450
 451     DPRINT("NtfsGetBothDirectoryInformation() called\n");
 452
 453     FileName = GetBestFileNameFromRecord(DeviceExt, FileRecord);
 454     if (FileName == NULL)
 455     {
 456         DPRINT1("No name information for file ID: %#I64x\n", MFTIndex);
 457         NtfsDumpFileAttributes(DeviceExt, FileRecord);
 458         return STATUS_OBJECT_NAME_NOT_FOUND;
 459     }
 460     ShortFileName = GetFileNameFromRecord(DeviceExt, FileRecord, NTFS_FILE_NAME_DOS);
 461
 462     StdInfo = GetStandardInformationFromRecord(DeviceExt, FileRecord);
 463     ASSERT(StdInfo != NULL);
 464
 465     Length = FileName->NameLength * sizeof (WCHAR);
 466     if ((sizeof(FILE_BOTH_DIR_INFORMATION) + Length) > BufferLength)
 467         return(STATUS_BUFFER_OVERFLOW);
 468
 469     Info->FileNameLength = Length;
 470     Info->NextEntryOffset =
 471         ROUND_UP(sizeof(FILE_BOTH_DIR_INFORMATION) + Length, sizeof(ULONG));
 472     RtlCopyMemory(Info->FileName, FileName->Name, Length);
 473
 474     if (ShortFileName)
 475     {
 476         /* Should we upcase the filename? */
 477         ASSERT(ShortFileName->NameLength <= ARRAYSIZE(Info->ShortName));
 478         Info->ShortNameLength = ShortFileName->NameLength * sizeof(WCHAR);
 479         RtlCopyMemory(Info->ShortName, ShortFileName->Name, Info->ShortNameLength);
 480     }
 481     else
 482     {
 483         Info->ShortName[0] = 0;
 484         Info->ShortNameLength = 0;
 485     }
 486
 487     Info->CreationTime.QuadPart = FileName->CreationTime;
 488     Info->LastAccessTime.QuadPart = FileName->LastAccessTime;
 489     Info->LastWriteTime.QuadPart = FileName->LastWriteTime;
 490     Info->ChangeTime.QuadPart = FileName->ChangeTime;
 491
 492     /* Convert file flags */
 493     NtfsFileFlagsToAttributes(FileName->FileAttributes | StdInfo->FileAttribute, &Info->FileAttributes);
 494
 495     Info->EndOfFile.QuadPart = NtfsGetFileSize(DeviceExt, FileRecord, L"", 0, (PULONGLONG)&Info->AllocationSize.QuadPart);
 496
 497     Info->FileIndex = MFTIndex;
 498     Info->EaSize = 0;
 499
 500     return STATUS_SUCCESS;
 501 }
 502
 503
 504 NTSTATUS
 505 NtfsQueryDirectory(PNTFS_IRP_CONTEXT IrpContext)
 506 {
 507     PIRP Irp;
 508     PDEVICE_OBJECT DeviceObject;
 509     PDEVICE_EXTENSION DeviceExtension;
 510     LONG BufferLength = 0;
 511     PUNICODE_STRING SearchPattern = NULL;
 512     FILE_INFORMATION_CLASS FileInformationClass;
 513     ULONG FileIndex = 0;
 514     PUCHAR Buffer = NULL;
 515     PFILE_NAMES_INFORMATION Buffer0 = NULL;
 516     PNTFS_FCB Fcb;
 517     PNTFS_CCB Ccb;
 518     BOOLEAN First = FALSE;
 519     PIO_STACK_LOCATION Stack;
 520     PFILE_OBJECT FileObject;
 521     NTSTATUS Status = STATUS_SUCCESS;
 522     PFILE_RECORD_HEADER FileRecord;
 523     ULONGLONG MFTRecord, OldMFTRecord = 0;
 524     UNICODE_STRING Pattern;
 525
 526     DPRINT1("NtfsQueryDirectory() called\n");
 527
 528     ASSERT(IrpContext);
 529     Irp = IrpContext->Irp;
 530     DeviceObject = IrpContext->DeviceObject;
 531
 532     DeviceExtension = DeviceObject->DeviceExtension;
 533     Stack = IoGetCurrentIrpStackLocation(Irp);
 534     FileObject = Stack->FileObject;
 535
 536     Ccb = (PNTFS_CCB)FileObject->FsContext2;
 537     Fcb = (PNTFS_FCB)FileObject->FsContext;
 538
 539     /* Obtain the callers parameters */
 540     BufferLength = Stack->Parameters.QueryDirectory.Length;
 541     SearchPattern = Stack->Parameters.QueryDirectory.FileName;
 542     FileInformationClass = Stack->Parameters.QueryDirectory.FileInformationClass;
 543     FileIndex = Stack->Parameters.QueryDirectory.FileIndex;
 544
 545     if (NtfsFCBIsCompressed(Fcb))
 546     {
 547         DPRINT1("Compressed directory!\n");
 548         UNIMPLEMENTED;
 549         return STATUS_NOT_IMPLEMENTED;
 550     }
 551
 552     if (!ExAcquireResourceSharedLite(&Fcb->MainResource,
 553                                      BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT)))
 554     {
 555         return STATUS_PENDING;
 556     }
 557
 558     if (SearchPattern != NULL)
 559     {
 560         if (!Ccb->DirectorySearchPattern)
 561         {
 562             First = TRUE;
 563             Pattern.Length = 0;
 564             Pattern.MaximumLength = SearchPattern->Length + sizeof(WCHAR);
 565             Ccb->DirectorySearchPattern = Pattern.Buffer =
 566                 ExAllocatePoolWithTag(NonPagedPool, Pattern.MaximumLength, TAG_NTFS);
 567             if (!Ccb->DirectorySearchPattern)
 568             {
 569                 ExReleaseResourceLite(&Fcb->MainResource);
 570                 return STATUS_INSUFFICIENT_RESOURCES;
 571             }
 572
 573             memcpy(Ccb->DirectorySearchPattern, SearchPattern->Buffer, SearchPattern->Length);
 574             Ccb->DirectorySearchPattern[SearchPattern->Length / sizeof(WCHAR)] = 0;
 575         }
 576     }
 577     else if (!Ccb->DirectorySearchPattern)
 578     {
 579         First = TRUE;
 580         Ccb->DirectorySearchPattern = ExAllocatePoolWithTag(NonPagedPool, 2 * sizeof(WCHAR), TAG_NTFS);
 581         if (!Ccb->DirectorySearchPattern)
 582         {
 583             ExReleaseResourceLite(&Fcb->MainResource);
 584             return STATUS_INSUFFICIENT_RESOURCES;
 585         }
 586
 587         Ccb->DirectorySearchPattern[0] = L'*';
 588         Ccb->DirectorySearchPattern[1] = 0;
 589     }
 590
 591     RtlInitUnicodeString(&Pattern, Ccb->DirectorySearchPattern);
 592     DPRINT("Search pattern '%S'\n", Ccb->DirectorySearchPattern);
 593     DPRINT("In: '%S'\n", Fcb->PathName);
 594
 595     /* Determine directory index */
 596     if (Stack->Flags & SL_INDEX_SPECIFIED)
 597     {
 598         Ccb->Entry = Ccb->CurrentByteOffset.u.LowPart;
 599     }
 600     else if (First || (Stack->Flags & SL_RESTART_SCAN))
 601     {
 602         Ccb->Entry = 0;
 603     }
 604
 605     /* Get Buffer for result */
 606     Buffer = NtfsGetUserBuffer(Irp, FALSE);
 607
 608     DPRINT("Buffer=%p tofind=%S\n", Buffer, Ccb->DirectorySearchPattern);
 609
 610     if (!ExAcquireResourceExclusiveLite(&DeviceExtension->DirResource,
 611                                         BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT)))
 612     {
 613         ExReleaseResourceLite(&Fcb->MainResource);
 614         return STATUS_PENDING;
 615     }
 616
 617     while (Status == STATUS_SUCCESS && BufferLength > 0)
 618     {
 619         Status = NtfsFindFileAt(DeviceExtension,
 620                                 &Pattern,
 621                                 &Ccb->Entry,
 622                                 &FileRecord,
 623                                 &MFTRecord,
 624                                 Fcb->MFTIndex,
 625                                 BooleanFlagOn(Stack->Flags, SL_CASE_SENSITIVE));
 626
 627         if (NT_SUCCESS(Status))
 628         {
 629             /* HACK: files with both a short name and a long name are present twice in the index.
 630              * Ignore the second entry, if it is immediately following the first one.
 631              */
 632             if (MFTRecord == OldMFTRecord)
 633             {
 634                 DPRINT1("Ignoring duplicate MFT entry 0x%x\n", MFTRecord);
 635                 Ccb->Entry++;
 636                 ExFreePoolWithTag(FileRecord, TAG_NTFS);
 637                 continue;
 638             }
 639             OldMFTRecord = MFTRecord;
 640
 641             switch (FileInformationClass)
 642             {
 643                 case FileNameInformation:
 644                     Status = NtfsGetNameInformation(DeviceExtension,
 645                                                     FileRecord,
 646                                                     MFTRecord,
 647                                                     (PFILE_NAMES_INFORMATION)Buffer,
 648                                                     BufferLength);
 649                     break;
 650
 651                 case FileDirectoryInformation:
 652                     Status = NtfsGetDirectoryInformation(DeviceExtension,
 653                                                          FileRecord,
 654                                                          MFTRecord,
 655                                                          (PFILE_DIRECTORY_INFORMATION)Buffer,
 656                                                          BufferLength);
 657                     break;
 658
 659                 case FileFullDirectoryInformation:
 660                     Status = NtfsGetFullDirectoryInformation(DeviceExtension,
 661                                                              FileRecord,
 662                                                              MFTRecord,
 663                                                              (PFILE_FULL_DIRECTORY_INFORMATION)Buffer,
 664                                                              BufferLength);
 665                     break;
 666
 667                 case FileBothDirectoryInformation:
 668                     Status = NtfsGetBothDirectoryInformation(DeviceExtension,
 669                                                              FileRecord,
 670                                                              MFTRecord,
 671                                                              (PFILE_BOTH_DIR_INFORMATION)Buffer,
 672                                                              BufferLength);
 673                     break;
 674
 675                 default:
 676                     Status = STATUS_INVALID_INFO_CLASS;
 677             }
 678
 679             if (Status == STATUS_BUFFER_OVERFLOW)
 680             {
 681                 if (Buffer0)
 682                 {
 683                     Buffer0->NextEntryOffset = 0;
 684                 }
 685                 break;
 686             }
 687         }
 688         else
 689         {
 690             if (Buffer0)
 691             {
 692                 Buffer0->NextEntryOffset = 0;
 693             }
 694
 695             if (First)
 696             {
 697                 Status = STATUS_NO_SUCH_FILE;
 698             }
 699             else
 700             {
 701                 Status = STATUS_NO_MORE_FILES;
 702             }
 703             break;
 704         }
 705
 706         Buffer0 = (PFILE_NAMES_INFORMATION)Buffer;
 707         Buffer0->FileIndex = FileIndex++;
 708         Ccb->Entry++;
 709
 710         if (Stack->Flags & SL_RETURN_SINGLE_ENTRY)
 711         {
 712             break;
 713         }
 714         BufferLength -= Buffer0->NextEntryOffset;
 715         Buffer += Buffer0->NextEntryOffset;
 716         ExFreePoolWithTag(FileRecord, TAG_NTFS);
 717     }
 718
 719     if (Buffer0)
 720     {
 721         Buffer0->NextEntryOffset = 0;
 722     }
 723
 724     ExReleaseResourceLite(&DeviceExtension->DirResource);
 725     ExReleaseResourceLite(&Fcb->MainResource);
 726
 727     if (FileIndex > 0)
 728     {
 729         Status = STATUS_SUCCESS;
 730     }
 731
 732     return Status;
 733 }
 734
 735
 736 NTSTATUS
 737 NtfsDirectoryControl(PNTFS_IRP_CONTEXT IrpContext)
 738 {
 739     NTSTATUS Status = STATUS_UNSUCCESSFUL;
 740
 741     DPRINT1("NtfsDirectoryControl() called\n");
 742
 743     switch (IrpContext->MinorFunction)
 744     {
 745         case IRP_MN_QUERY_DIRECTORY:
 746             Status = NtfsQueryDirectory(IrpContext);
 747             break;
 748
 749         case IRP_MN_NOTIFY_CHANGE_DIRECTORY:
 750             DPRINT1("IRP_MN_NOTIFY_CHANGE_DIRECTORY\n");
 751             Status = STATUS_NOT_IMPLEMENTED;
 752             break;
 753
 754         default:
 755             Status = STATUS_INVALID_DEVICE_REQUEST;
 756             break;
 757     }
 758
 759     if (Status == STATUS_PENDING && IrpContext->Flags & IRPCONTEXT_COMPLETE)
 760     {
 761         return NtfsMarkIrpContextForQueue(IrpContext);
 762     }
 763
 764     IrpContext->Irp->IoStatus.Information = 0;
 765
 766     return Status;
 767 }
 768
 769 /* EOF */