reactos/drivers/filesystems/ntfs/mft.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2002, 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/mft.c
  22  * PURPOSE:          NTFS filesystem driver
  23  * PROGRAMMERS:      Eric Kohl
  24  *                   Valentin Verkhovsky
  25  *                   Pierre Schweitzer (pierre@reactos.org)
  26  *                   Hervé Poussineau (hpoussin@reactos.org)
  27  */
  28
  29 /* INCLUDES *****************************************************************/
  30
  31 #include "ntfs.h"
  32
  33 #define NDEBUG
  34 #include <debug.h>
  35
  36 /* FUNCTIONS ****************************************************************/
  37
  38 PNTFS_ATTR_CONTEXT
  39 PrepareAttributeContext(PNTFS_ATTR_RECORD AttrRecord)
  40 {
  41     PNTFS_ATTR_CONTEXT Context;
  42
  43     Context = ExAllocatePoolWithTag(NonPagedPool,
  44                                     FIELD_OFFSET(NTFS_ATTR_CONTEXT, Record) + AttrRecord->Length,
  45                                     TAG_NTFS);
  46     RtlCopyMemory(&Context->Record, AttrRecord, AttrRecord->Length);
  47     if (AttrRecord->IsNonResident)
  48     {
  49         LONGLONG DataRunOffset;
  50         ULONGLONG DataRunLength;
  51
  52         Context->CacheRun = (PUCHAR)&Context->Record + Context->Record.NonResident.MappingPairsOffset;
  53         Context->CacheRunOffset = 0;
  54         Context->CacheRun = DecodeRun(Context->CacheRun, &DataRunOffset, &DataRunLength);
  55         Context->CacheRunLength = DataRunLength;
  56         if (DataRunOffset != -1)
  57         {
  58             /* Normal run. */
  59             Context->CacheRunStartLCN =
  60             Context->CacheRunLastLCN = DataRunOffset;
  61         }
  62         else
  63         {
  64             /* Sparse run. */
  65             Context->CacheRunStartLCN = -1;
  66             Context->CacheRunLastLCN = 0;
  67         }
  68         Context->CacheRunCurrentOffset = 0;
  69     }
  70
  71     return Context;
  72 }
  73
  74
  75 VOID
  76 ReleaseAttributeContext(PNTFS_ATTR_CONTEXT Context)
  77 {
  78     ExFreePoolWithTag(Context, TAG_NTFS);
  79 }
  80
  81
  82 PNTFS_ATTR_CONTEXT
  83 FindAttributeHelper(PDEVICE_EXTENSION Vcb,
  84                     PNTFS_ATTR_RECORD AttrRecord,
  85                     PNTFS_ATTR_RECORD AttrRecordEnd,
  86                     ULONG Type,
  87                     PCWSTR Name,
  88                     ULONG NameLength)
  89 {
  90     DPRINT("FindAttributeHelper(%p, %p, %p, 0x%x, %S, %u)\n", Vcb, AttrRecord, AttrRecordEnd, Type, Name, NameLength);
  91
  92     while (AttrRecord < AttrRecordEnd)
  93     {
  94         DPRINT("AttrRecord->Type = 0x%x\n", AttrRecord->Type);
  95
  96         if (AttrRecord->Type == AttributeEnd)
  97             break;
  98
  99         if (AttrRecord->Type == AttributeAttributeList)
 100         {
 101             PNTFS_ATTR_CONTEXT Context;
 102             PNTFS_ATTR_CONTEXT ListContext;
 103             PVOID ListBuffer;
 104             ULONGLONG ListSize;
 105             PNTFS_ATTR_RECORD ListAttrRecord;
 106             PNTFS_ATTR_RECORD ListAttrRecordEnd;
 107
 108             ListContext = PrepareAttributeContext(AttrRecord);
 109
 110             ListSize = AttributeDataLength(&ListContext->Record);
 111             if(ListSize <= 0xFFFFFFFF)
 112                 ListBuffer = ExAllocatePoolWithTag(NonPagedPool, (ULONG)ListSize, TAG_NTFS);
 113             else
 114                 ListBuffer = NULL;
 115
 116             if(!ListBuffer)
 117             {
 118                 DPRINT("Failed to allocate memory: %x\n", (ULONG)ListSize);
 119                 continue;
 120             }
 121
 122             ListAttrRecord = (PNTFS_ATTR_RECORD)ListBuffer;
 123             ListAttrRecordEnd = (PNTFS_ATTR_RECORD)((PCHAR)ListBuffer + ListSize);
 124
 125             if (ReadAttribute(Vcb, ListContext, 0, ListBuffer, (ULONG)ListSize) == ListSize)
 126             {
 127                 Context = FindAttributeHelper(Vcb, ListAttrRecord, ListAttrRecordEnd,
 128                                               Type, Name, NameLength);
 129
 130                 ReleaseAttributeContext(ListContext);
 131                 ExFreePoolWithTag(ListBuffer, TAG_NTFS);
 132
 133                 if (Context != NULL)
 134                 {
 135                     if (AttrRecord->IsNonResident) DPRINT("Found context = %p\n", Context);
 136                     return Context;
 137                 }
 138             }
 139         }
 140
 141         if (AttrRecord->Type == Type)
 142         {
 143             if (AttrRecord->NameLength == NameLength)
 144             {
 145                 PWCHAR AttrName;
 146
 147                 AttrName = (PWCHAR)((PCHAR)AttrRecord + AttrRecord->NameOffset);
 148                 DPRINT("%.*S, %.*S\n", AttrRecord->NameLength, AttrName, NameLength, Name);
 149                 if (RtlCompareMemory(AttrName, Name, NameLength << 1) == (NameLength << 1))
 150                 {
 151                     /* Found it, fill up the context and return. */
 152                     DPRINT("Found context\n");
 153                     return PrepareAttributeContext(AttrRecord);
 154                 }
 155             }
 156         }
 157
 158         if (AttrRecord->Length == 0)
 159         {
 160             DPRINT("Null length attribute record\n");
 161             return NULL;
 162         }
 163         AttrRecord = (PNTFS_ATTR_RECORD)((PCHAR)AttrRecord + AttrRecord->Length);
 164     }
 165
 166     DPRINT("Ended\n");
 167     return NULL;
 168 }
 169
 170
 171 NTSTATUS
 172 FindAttribute(PDEVICE_EXTENSION Vcb,
 173               PFILE_RECORD_HEADER MftRecord,
 174               ULONG Type,
 175               PCWSTR Name,
 176               ULONG NameLength,
 177               PNTFS_ATTR_CONTEXT * AttrCtx)
 178 {
 179     PNTFS_ATTR_RECORD AttrRecord;
 180     PNTFS_ATTR_RECORD AttrRecordEnd;
 181
 182     DPRINT("FindAttribute(%p, %p, 0x%x, %S, %u, %p)\n", Vcb, MftRecord, Type, Name, NameLength, AttrCtx);
 183
 184     AttrRecord = (PNTFS_ATTR_RECORD)((PCHAR)MftRecord + MftRecord->AttributeOffset);
 185     AttrRecordEnd = (PNTFS_ATTR_RECORD)((PCHAR)MftRecord + Vcb->NtfsInfo.BytesPerFileRecord);
 186
 187     *AttrCtx = FindAttributeHelper(Vcb, AttrRecord, AttrRecordEnd, Type, Name, NameLength);
 188     if (*AttrCtx == NULL)
 189     {
 190         return STATUS_OBJECT_NAME_NOT_FOUND;
 191     }
 192
 193     return STATUS_SUCCESS;
 194 }
 195
 196
 197 ULONG
 198 AttributeAllocatedLength(PNTFS_ATTR_RECORD AttrRecord)
 199 {
 200     if (AttrRecord->IsNonResident)
 201         return AttrRecord->NonResident.AllocatedSize;
 202     else
 203         return AttrRecord->Resident.ValueLength;
 204 }
 205
 206
 207 ULONGLONG
 208 AttributeDataLength(PNTFS_ATTR_RECORD AttrRecord)
 209 {
 210     if (AttrRecord->IsNonResident)
 211         return AttrRecord->NonResident.DataSize;
 212     else
 213         return AttrRecord->Resident.ValueLength;
 214 }
 215
 216
 217 ULONG
 218 ReadAttribute(PDEVICE_EXTENSION Vcb,
 219               PNTFS_ATTR_CONTEXT Context,
 220               ULONGLONG Offset,
 221               PCHAR Buffer,
 222               ULONG Length)
 223 {
 224     ULONGLONG LastLCN;
 225     PUCHAR DataRun;
 226     LONGLONG DataRunOffset;
 227     ULONGLONG DataRunLength;
 228     LONGLONG DataRunStartLCN;
 229     ULONGLONG CurrentOffset;
 230     ULONG ReadLength;
 231     ULONG AlreadyRead;
 232     NTSTATUS Status;
 233
 234     if (!Context->Record.IsNonResident)
 235     {
 236         if (Offset > Context->Record.Resident.ValueLength)
 237             return 0;
 238         if (Offset + Length > Context->Record.Resident.ValueLength)
 239             Length = (ULONG)(Context->Record.Resident.ValueLength - Offset);
 240         RtlCopyMemory(Buffer, (PCHAR)&Context->Record + Context->Record.Resident.ValueOffset + Offset, Length);
 241         return Length;
 242     }
 243
 244     /*
 245      * Non-resident attribute
 246      */
 247
 248     /*
 249      * I. Find the corresponding start data run.
 250      */
 251
 252     AlreadyRead = 0;
 253
 254     // FIXME: Cache seems to be non-working. Disable it for now
 255     //if(Context->CacheRunOffset <= Offset && Offset < Context->CacheRunOffset + Context->CacheRunLength * Volume->ClusterSize)
 256     if (0)
 257     {
 258         DataRun = Context->CacheRun;
 259         LastLCN = Context->CacheRunLastLCN;
 260         DataRunStartLCN = Context->CacheRunStartLCN;
 261         DataRunLength = Context->CacheRunLength;
 262         CurrentOffset = Context->CacheRunCurrentOffset;
 263     }
 264     else
 265     {
 266         LastLCN = 0;
 267         DataRun = (PUCHAR)&Context->Record + Context->Record.NonResident.MappingPairsOffset;
 268         CurrentOffset = 0;
 269
 270         while (1)
 271         {
 272             DataRun = DecodeRun(DataRun, &DataRunOffset, &DataRunLength);
 273             if (DataRunOffset != -1)
 274             {
 275                 /* Normal data run. */
 276                 DataRunStartLCN = LastLCN + DataRunOffset;
 277                 LastLCN = DataRunStartLCN;
 278             }
 279             else
 280             {
 281                 /* Sparse data run. */
 282                 DataRunStartLCN = -1;
 283             }
 284
 285             if (Offset >= CurrentOffset &&
 286                 Offset < CurrentOffset + (DataRunLength * Vcb->NtfsInfo.BytesPerCluster))
 287             {
 288                 break;
 289             }
 290
 291             if (*DataRun == 0)
 292             {
 293                 return AlreadyRead;
 294             }
 295
 296             CurrentOffset += DataRunLength * Vcb->NtfsInfo.BytesPerCluster;
 297         }
 298     }
 299
 300     /*
 301      * II. Go through the run list and read the data
 302      */
 303
 304     ReadLength = (ULONG)min(DataRunLength * Vcb->NtfsInfo.BytesPerCluster - (Offset - CurrentOffset), Length);
 305     if (DataRunStartLCN == -1)
 306         RtlZeroMemory(Buffer, ReadLength);
 307     Status = NtfsReadDisk(Vcb->StorageDevice,
 308                           DataRunStartLCN * Vcb->NtfsInfo.BytesPerCluster + Offset - CurrentOffset,
 309                           ReadLength,
 310                           Vcb->NtfsInfo.BytesPerSector,
 311                           (PVOID)Buffer,
 312                           FALSE);
 313     if (NT_SUCCESS(Status))
 314     {
 315         Length -= ReadLength;
 316         Buffer += ReadLength;
 317         AlreadyRead += ReadLength;
 318
 319         if (ReadLength == DataRunLength * Vcb->NtfsInfo.BytesPerCluster - (Offset - CurrentOffset))
 320         {
 321             CurrentOffset += DataRunLength * Vcb->NtfsInfo.BytesPerCluster;
 322             DataRun = DecodeRun(DataRun, &DataRunOffset, &DataRunLength);
 323             if (DataRunLength != (ULONGLONG)-1)
 324             {
 325                 DataRunStartLCN = LastLCN + DataRunOffset;
 326                 LastLCN = DataRunStartLCN;
 327             }
 328             else
 329                 DataRunStartLCN = -1;
 330
 331             if (*DataRun == 0)
 332                 return AlreadyRead;
 333         }
 334
 335         while (Length > 0)
 336         {
 337             ReadLength = (ULONG)min(DataRunLength * Vcb->NtfsInfo.BytesPerCluster, Length);
 338             if (DataRunStartLCN == -1)
 339                 RtlZeroMemory(Buffer, ReadLength);
 340             else
 341             {
 342                 Status = NtfsReadDisk(Vcb->StorageDevice,
 343                                       DataRunStartLCN * Vcb->NtfsInfo.BytesPerCluster,
 344                                       ReadLength,
 345                                       Vcb->NtfsInfo.BytesPerSector,
 346                                       (PVOID)Buffer,
 347                                       FALSE);
 348                 if (!NT_SUCCESS(Status))
 349                     break;
 350             }
 351
 352             Length -= ReadLength;
 353             Buffer += ReadLength;
 354             AlreadyRead += ReadLength;
 355
 356             /* We finished this request, but there still data in this data run. */
 357             if (Length == 0 && ReadLength != DataRunLength * Vcb->NtfsInfo.BytesPerCluster)
 358                 break;
 359
 360             /*
 361              * Go to next run in the list.
 362              */
 363
 364             if (*DataRun == 0)
 365                 break;
 366             CurrentOffset += DataRunLength * Vcb->NtfsInfo.BytesPerCluster;
 367             DataRun = DecodeRun(DataRun, &DataRunOffset, &DataRunLength);
 368             if (DataRunOffset != -1)
 369             {
 370                 /* Normal data run. */
 371                 DataRunStartLCN = LastLCN + DataRunOffset;
 372                 LastLCN = DataRunStartLCN;
 373             }
 374             else
 375             {
 376                 /* Sparse data run. */
 377                 DataRunStartLCN = -1;
 378             }
 379         } /* while */
 380
 381     } /* if Disk */
 382
 383     Context->CacheRun = DataRun;
 384     Context->CacheRunOffset = Offset + AlreadyRead;
 385     Context->CacheRunStartLCN = DataRunStartLCN;
 386     Context->CacheRunLength = DataRunLength;
 387     Context->CacheRunLastLCN = LastLCN;
 388     Context->CacheRunCurrentOffset = CurrentOffset;
 389
 390     return AlreadyRead;
 391 }
 392
 393
 394 NTSTATUS
 395 ReadFileRecord(PDEVICE_EXTENSION Vcb,
 396                ULONGLONG index,
 397                PFILE_RECORD_HEADER file)
 398 {
 399     ULONGLONG BytesRead;
 400
 401     DPRINT("ReadFileRecord(%p, %I64x, %p)\n", Vcb, index, file);
 402
 403     BytesRead = ReadAttribute(Vcb, Vcb->MFTContext, index * Vcb->NtfsInfo.BytesPerFileRecord, (PCHAR)file, Vcb->NtfsInfo.BytesPerFileRecord);
 404     if (BytesRead != Vcb->NtfsInfo.BytesPerFileRecord)
 405     {
 406         DPRINT1("ReadFileRecord failed: %I64u read, %u expected\n", BytesRead, Vcb->NtfsInfo.BytesPerFileRecord);
 407         return STATUS_PARTIAL_COPY;
 408     }
 409
 410     /* Apply update sequence array fixups. */
 411     return FixupUpdateSequenceArray(Vcb, &file->Ntfs);
 412 }
 413
 414
 415 NTSTATUS
 416 FixupUpdateSequenceArray(PDEVICE_EXTENSION Vcb,
 417                          PNTFS_RECORD_HEADER Record)
 418 {
 419     USHORT *USA;
 420     USHORT USANumber;
 421     USHORT USACount;
 422     USHORT *Block;
 423
 424     USA = (USHORT*)((PCHAR)Record + Record->UsaOffset);
 425     USANumber = *(USA++);
 426     USACount = Record->UsaCount - 1; /* Exclude the USA Number. */
 427     Block = (USHORT*)((PCHAR)Record + Vcb->NtfsInfo.BytesPerSector - 2);
 428
 429     while (USACount)
 430     {
 431         if (*Block != USANumber)
 432         {
 433             DPRINT1("Mismatch with USA: %u read, %u expected\n" , *Block, USANumber);
 434             return STATUS_UNSUCCESSFUL;
 435         }
 436         *Block = *(USA++);
 437         Block = (USHORT*)((PCHAR)Block + Vcb->NtfsInfo.BytesPerSector);
 438         USACount--;
 439     }
 440
 441     return STATUS_SUCCESS;
 442 }
 443
 444
 445 NTSTATUS
 446 ReadLCN(PDEVICE_EXTENSION Vcb,
 447         ULONGLONG lcn,
 448         ULONG count,
 449         PVOID buffer)
 450 {
 451     LARGE_INTEGER DiskSector;
 452
 453     DiskSector.QuadPart = lcn;
 454
 455     return NtfsReadSectors(Vcb->StorageDevice,
 456                            DiskSector.u.LowPart * Vcb->NtfsInfo.SectorsPerCluster,
 457                            count * Vcb->NtfsInfo.SectorsPerCluster,
 458                            Vcb->NtfsInfo.BytesPerSector,
 459                            buffer,
 460                            FALSE);
 461 }
 462
 463
 464 BOOLEAN
 465 CompareFileName(PUNICODE_STRING FileName,
 466                 PINDEX_ENTRY_ATTRIBUTE IndexEntry,
 467                 BOOLEAN DirSearch)
 468 {
 469     BOOLEAN Ret, Alloc = FALSE;
 470     UNICODE_STRING EntryName;
 471
 472     EntryName.Buffer = IndexEntry->FileName.Name;
 473     EntryName.Length =
 474     EntryName.MaximumLength = IndexEntry->FileName.NameLength * sizeof(WCHAR);
 475
 476     if (DirSearch)
 477     {
 478         UNICODE_STRING IntFileName;
 479         if (IndexEntry->FileName.NameType != NTFS_FILE_NAME_POSIX)
 480         {
 481             NT_VERIFY(NT_SUCCESS(RtlUpcaseUnicodeString(&IntFileName, FileName, TRUE)));
 482             Alloc = TRUE;
 483         }
 484         else
 485         {
 486             IntFileName = *FileName;
 487         }
 488
 489         Ret = FsRtlIsNameInExpression(&IntFileName, &EntryName, (IndexEntry->FileName.NameType != NTFS_FILE_NAME_POSIX), NULL);
 490
 491         if (Alloc)
 492         {
 493             RtlFreeUnicodeString(&IntFileName);
 494         }
 495
 496         return Ret;
 497     }
 498     else
 499     {
 500         return (RtlCompareUnicodeString(FileName, &EntryName, (IndexEntry->FileName.NameType != NTFS_FILE_NAME_POSIX)) == 0);
 501     }
 502 }
 503
 504
 505 NTSTATUS
 506 NtfsFindMftRecord(PDEVICE_EXTENSION Vcb,
 507                   ULONGLONG MFTIndex,
 508                   PUNICODE_STRING FileName,
 509                   PULONG FirstEntry,
 510                   BOOLEAN DirSearch,
 511                   ULONGLONG *OutMFTIndex)
 512 {
 513     PFILE_RECORD_HEADER MftRecord;
 514     PNTFS_ATTR_CONTEXT IndexRootCtx;
 515     PNTFS_ATTR_CONTEXT IndexBitmapCtx;
 516     PNTFS_ATTR_CONTEXT IndexAllocationCtx;
 517     PINDEX_ROOT_ATTRIBUTE IndexRoot;
 518     PINDEX_BUFFER IndexBuffer;
 519     ULONGLONG BitmapDataSize;
 520     ULONGLONG IndexAllocationSize;
 521     PCHAR BitmapData;
 522     PCHAR IndexRecord;
 523     PINDEX_ENTRY_ATTRIBUTE IndexEntry, IndexEntryEnd;
 524     ULONG RecordOffset;
 525     ULONG IndexBlockSize;
 526     NTSTATUS Status;
 527     ULONG CurrentEntry = 0;
 528
 529     DPRINT("NtfsFindMftRecord(%p, %I64d, %wZ, %p, %u, %p)\n", Vcb, MFTIndex, FileName, FirstEntry, DirSearch, OutMFTIndex);
 530
 531     MftRecord = ExAllocatePoolWithTag(NonPagedPool,
 532                                       Vcb->NtfsInfo.BytesPerFileRecord,
 533                                       TAG_NTFS);
 534     if (MftRecord == NULL)
 535     {
 536         return STATUS_INSUFFICIENT_RESOURCES;
 537     }
 538
 539     if (NT_SUCCESS(ReadFileRecord(Vcb, MFTIndex, MftRecord)))
 540     {
 541         ASSERT(MftRecord->Ntfs.Type == NRH_FILE_TYPE);
 542
 543         Status = FindAttribute(Vcb, MftRecord, AttributeIndexRoot, L"$I30", 4, &IndexRootCtx);
 544         if (!NT_SUCCESS(Status))
 545         {
 546             ExFreePoolWithTag(MftRecord, TAG_NTFS);
 547             return Status;
 548         }
 549
 550         IndexRecord = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerIndexRecord, TAG_NTFS);
 551         if (IndexRecord == NULL)
 552         {
 553             ExFreePoolWithTag(MftRecord, TAG_NTFS);
 554             return STATUS_INSUFFICIENT_RESOURCES;
 555         }
 556
 557         ReadAttribute(Vcb, IndexRootCtx, 0, IndexRecord, Vcb->NtfsInfo.BytesPerIndexRecord);
 558         IndexRoot = (PINDEX_ROOT_ATTRIBUTE)IndexRecord;
 559         IndexEntry = (PINDEX_ENTRY_ATTRIBUTE)((PCHAR)&IndexRoot->Header + IndexRoot->Header.FirstEntryOffset);
 560         /* Index root is always resident. */
 561         IndexEntryEnd = (PINDEX_ENTRY_ATTRIBUTE)(IndexRecord + IndexRoot->Header.TotalSizeOfEntries);
 562         ReleaseAttributeContext(IndexRootCtx);
 563
 564         DPRINT("IndexRecordSize: %x IndexBlockSize: %x\n", Vcb->NtfsInfo.BytesPerIndexRecord, IndexRoot->SizeOfEntry);
 565
 566         while (IndexEntry < IndexEntryEnd &&
 567                !(IndexEntry->Flags & NTFS_INDEX_ENTRY_END))
 568         {
 569             UNICODE_STRING EntryName;
 570             EntryName.Buffer = IndexEntry->FileName.Name;
 571             EntryName.Length =
 572             EntryName.MaximumLength = IndexEntry->FileName.NameLength * sizeof(WCHAR);
 573
 574             if (IndexEntry->Flags & NTFS_INDEX_ENTRY_NODE)
 575                 DPRINT1("Warning: sub-node browsing unimplemented! (%wZ)\n", &EntryName);
 576
 577             if ((IndexEntry->Data.Directory.IndexedFile & NTFS_MFT_MASK) > 0x10 &&
 578                 CurrentEntry >= *FirstEntry &&
 579                 CompareFileName(FileName, IndexEntry, DirSearch))
 580             {
 581                 *OutMFTIndex = (IndexEntry->Data.Directory.IndexedFile & NTFS_MFT_MASK);
 582                 *FirstEntry = CurrentEntry;
 583                 ExFreePoolWithTag(IndexRecord, TAG_NTFS);
 584                 ExFreePoolWithTag(MftRecord, TAG_NTFS);
 585                 return STATUS_SUCCESS;
 586             }
 587
 588             ++CurrentEntry;
 589             IndexEntry = (PINDEX_ENTRY_ATTRIBUTE)((PCHAR)IndexEntry + IndexEntry->Length);
 590         }
 591
 592         if (IndexRoot->Header.Flags & INDEX_ROOT_LARGE)
 593         {
 594             DPRINT("Large Index!\n");
 595
 596             IndexBlockSize = IndexRoot->SizeOfEntry;
 597
 598             Status = FindAttribute(Vcb, MftRecord, AttributeBitmap, L"$I30", 4, &IndexBitmapCtx);
 599             if (!NT_SUCCESS(Status))
 600             {
 601                 DPRINT1("Corrupted filesystem!\n");
 602                 ExFreePoolWithTag(MftRecord, TAG_NTFS);
 603                 return Status;
 604             }
 605             BitmapDataSize = AttributeDataLength(&IndexBitmapCtx->Record);
 606             DPRINT("BitmapDataSize: %x\n", (ULONG)BitmapDataSize);
 607             if(BitmapDataSize <= 0xFFFFFFFF)
 608                 BitmapData = ExAllocatePoolWithTag(NonPagedPool, (ULONG)BitmapDataSize, TAG_NTFS);
 609             else
 610                 BitmapData = NULL;
 611
 612             if (BitmapData == NULL)
 613             {
 614                 ExFreePoolWithTag(IndexRecord, TAG_NTFS);
 615                 ExFreePoolWithTag(MftRecord, TAG_NTFS);
 616                 return STATUS_INSUFFICIENT_RESOURCES;
 617             }
 618             ReadAttribute(Vcb, IndexBitmapCtx, 0, BitmapData, (ULONG)BitmapDataSize);
 619             ReleaseAttributeContext(IndexBitmapCtx);
 620
 621             Status = FindAttribute(Vcb, MftRecord, AttributeIndexAllocation, L"$I30", 4, &IndexAllocationCtx);
 622             if (!NT_SUCCESS(Status))
 623             {
 624                 DPRINT("Corrupted filesystem!\n");
 625                 ExFreePoolWithTag(BitmapData, TAG_NTFS);
 626                 ExFreePoolWithTag(IndexRecord, TAG_NTFS);
 627                 ExFreePoolWithTag(MftRecord, TAG_NTFS);
 628                 return Status;
 629             }
 630             IndexAllocationSize = AttributeDataLength(&IndexAllocationCtx->Record);
 631
 632             RecordOffset = 0;
 633
 634             for (;;)
 635             {
 636                 DPRINT("RecordOffset: %x IndexAllocationSize: %x\n", RecordOffset, IndexAllocationSize);
 637                 for (; RecordOffset < IndexAllocationSize;)
 638                 {
 639                     UCHAR Bit = 1 << ((RecordOffset / IndexBlockSize) & 7);
 640                     ULONG Byte = (RecordOffset / IndexBlockSize) >> 3;
 641                     if ((BitmapData[Byte] & Bit))
 642                         break;
 643                     RecordOffset += IndexBlockSize;
 644                 }
 645
 646                 if (RecordOffset >= IndexAllocationSize)
 647                 {
 648                     break;
 649                 }
 650
 651                 ReadAttribute(Vcb, IndexAllocationCtx, RecordOffset, IndexRecord, IndexBlockSize);
 652
 653                 if (!NT_SUCCESS(FixupUpdateSequenceArray(Vcb, &((PFILE_RECORD_HEADER)IndexRecord)->Ntfs)))
 654                 {
 655                     break;
 656                 }
 657
 658                 IndexBuffer = (PINDEX_BUFFER)IndexRecord;
 659                 ASSERT(IndexBuffer->Ntfs.Type == NRH_INDX_TYPE);
 660                 ASSERT(IndexBuffer->Header.AllocatedSize + 0x18 == IndexBlockSize);
 661                 IndexEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)&IndexBuffer->Header + IndexBuffer->Header.FirstEntryOffset);
 662                 IndexEntryEnd = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)&IndexBuffer->Header + IndexBuffer->Header.TotalSizeOfEntries);
 663                 ASSERT(IndexEntryEnd <= (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)IndexBuffer + IndexBlockSize));
 664
 665                 while (IndexEntry < IndexEntryEnd &&
 666                        !(IndexEntry->Flags & NTFS_INDEX_ENTRY_END))
 667                 {
 668                     UNICODE_STRING EntryName;
 669                     EntryName.Buffer = IndexEntry->FileName.Name;
 670                     EntryName.Length =
 671                     EntryName.MaximumLength = IndexEntry->FileName.NameLength * sizeof(WCHAR);
 672
 673                     if (IndexEntry->Flags & NTFS_INDEX_ENTRY_NODE)
 674                         DPRINT1("Warning: sub-node browsing unimplemented! (%wZ)\n", &EntryName);
 675
 676                     if ((IndexEntry->Data.Directory.IndexedFile & NTFS_MFT_MASK) > 0x10 &&
 677                         CurrentEntry >= *FirstEntry &&
 678                         CompareFileName(FileName, IndexEntry, DirSearch))
 679                     {
 680                         DPRINT("File found\n");
 681                         *OutMFTIndex = (IndexEntry->Data.Directory.IndexedFile & NTFS_MFT_MASK);
 682                         *FirstEntry = CurrentEntry;
 683                         ExFreePoolWithTag(BitmapData, TAG_NTFS);
 684                         ExFreePoolWithTag(IndexRecord, TAG_NTFS);
 685                         ExFreePoolWithTag(MftRecord, TAG_NTFS);
 686                         ReleaseAttributeContext(IndexAllocationCtx);
 687                         return STATUS_SUCCESS;
 688                     }
 689
 690                     ++CurrentEntry;
 691                     ASSERT(IndexEntry->Length >= sizeof(INDEX_ENTRY_ATTRIBUTE));
 692                     IndexEntry = (PINDEX_ENTRY_ATTRIBUTE)((PCHAR)IndexEntry + IndexEntry->Length);
 693                 }
 694
 695                 RecordOffset += IndexBlockSize;
 696             }
 697
 698             ReleaseAttributeContext(IndexAllocationCtx);
 699             ExFreePoolWithTag(BitmapData, TAG_NTFS);
 700         }
 701
 702         ExFreePoolWithTag(IndexRecord, TAG_NTFS);
 703     }
 704     else
 705     {
 706         DPRINT("Can't read MFT record\n");
 707     }
 708     ExFreePoolWithTag(MftRecord, TAG_NTFS);
 709
 710     return STATUS_OBJECT_PATH_NOT_FOUND;
 711 }
 712
 713 NTSTATUS
 714 NtfsLookupFileAt(PDEVICE_EXTENSION Vcb,
 715                  PUNICODE_STRING PathName,
 716                  PFILE_RECORD_HEADER *FileRecord,
 717                  PNTFS_ATTR_CONTEXT *DataContext,
 718                  PULONGLONG MFTIndex,
 719                  ULONGLONG CurrentMFTIndex)
 720 {
 721     UNICODE_STRING Current, Remaining;
 722     NTSTATUS Status;
 723     ULONG FirstEntry = 0;
 724
 725     DPRINT("NtfsLookupFileAt(%p, %wZ, %p, %p, %I64x)\n", Vcb, PathName, FileRecord, DataContext, CurrentMFTIndex);
 726
 727     FsRtlDissectName(*PathName, &Current, &Remaining);
 728
 729     while (Current.Length != 0)
 730     {
 731         DPRINT("Current: %wZ\n", &Current);
 732
 733         Status = NtfsFindMftRecord(Vcb, CurrentMFTIndex, &Current, &FirstEntry, FALSE, &CurrentMFTIndex);
 734         if (!NT_SUCCESS(Status))
 735         {
 736             return Status;
 737         }
 738
 739         if (Remaining.Length == 0)
 740             break;
 741
 742         FsRtlDissectName(Current, &Current, &Remaining);
 743     }
 744
 745     *FileRecord = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS);
 746     if (*FileRecord == NULL)
 747     {
 748         DPRINT("NtfsLookupFileAt: Can't allocate MFT record\n");
 749         return STATUS_INSUFFICIENT_RESOURCES;
 750     }
 751
 752     Status = ReadFileRecord(Vcb, CurrentMFTIndex, *FileRecord);
 753     if (!NT_SUCCESS(Status))
 754     {
 755         DPRINT("NtfsLookupFileAt: Can't read MFT record\n");
 756         ExFreePoolWithTag(*FileRecord, TAG_NTFS);
 757         return Status;
 758     }
 759
 760     if (!((*FileRecord)->Flags & FRH_DIRECTORY))
 761     {
 762         Status = FindAttribute(Vcb, *FileRecord, AttributeData, L"", 0, DataContext);
 763         if (!NT_SUCCESS(Status))
 764         {
 765             DPRINT("NtfsLookupFileAt: Can't find data attribute\n");
 766             ExFreePoolWithTag(*FileRecord, TAG_NTFS);
 767             return Status;
 768         }
 769     }
 770     else
 771     {
 772         *DataContext = NULL;
 773     }
 774
 775     *MFTIndex = CurrentMFTIndex;
 776
 777     return STATUS_SUCCESS;
 778 }
 779
 780 NTSTATUS
 781 NtfsLookupFile(PDEVICE_EXTENSION Vcb,
 782                PUNICODE_STRING PathName,
 783                PFILE_RECORD_HEADER *FileRecord,
 784                PNTFS_ATTR_CONTEXT *DataContext,
 785                PULONGLONG MFTIndex)
 786 {
 787     return NtfsLookupFileAt(Vcb, PathName, FileRecord, DataContext, MFTIndex, NTFS_FILE_ROOT);
 788 }
 789
 790 NTSTATUS
 791 NtfsFindFileAt(PDEVICE_EXTENSION Vcb,
 792                PUNICODE_STRING SearchPattern,
 793                PULONG FirstEntry,
 794                PFILE_RECORD_HEADER *FileRecord,
 795                PNTFS_ATTR_CONTEXT *DataContext,
 796                PULONGLONG MFTIndex,
 797                ULONGLONG CurrentMFTIndex)
 798 {
 799     NTSTATUS Status;
 800
 801     DPRINT("NtfsFindFileAt(%p, %wZ, %p, %p, %p, %p, %I64x)\n", Vcb, SearchPattern, FirstEntry, FileRecord, DataContext, MFTIndex, CurrentMFTIndex);
 802
 803     Status = NtfsFindMftRecord(Vcb, CurrentMFTIndex, SearchPattern, FirstEntry, TRUE, &CurrentMFTIndex);
 804     if (!NT_SUCCESS(Status))
 805     {
 806         DPRINT("NtfsFindFileAt: NtfsFindMftRecord() failed with status 0x%08lx\n", Status);
 807         return Status;
 808     }
 809
 810     *FileRecord = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS);
 811     if (*FileRecord == NULL)
 812     {
 813         DPRINT("NtfsFindFileAt: Can't allocate MFT record\n");
 814         return STATUS_INSUFFICIENT_RESOURCES;
 815     }
 816
 817     Status = ReadFileRecord(Vcb, CurrentMFTIndex, *FileRecord);
 818     if (!NT_SUCCESS(Status))
 819     {
 820         DPRINT("NtfsFindFileAt: Can't read MFT record\n");
 821         ExFreePoolWithTag(*FileRecord, TAG_NTFS);
 822         return Status;
 823     }
 824
 825     if (!((*FileRecord)->Flags & FRH_DIRECTORY))
 826     {
 827         Status = FindAttribute(Vcb, *FileRecord, AttributeData, L"", 0, DataContext);
 828         if (!NT_SUCCESS(Status))
 829         {
 830             DPRINT("NtfsFindFileAt: Can't find data attribute\n");
 831             ExFreePoolWithTag(*FileRecord, TAG_NTFS);
 832             return Status;
 833         }
 834     }
 835     else
 836     {
 837         *DataContext = NULL;
 838     }
 839
 840     *MFTIndex = CurrentMFTIndex;
 841
 842     return STATUS_SUCCESS;
 843 }
 844
 845 /* EOF */