[FASTFAT] Fix size checking in VfatGetFileNameInformation()
[reactos.git] / drivers / filesystems / ntfs / fcb.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/fcb.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 static
38 PWCHAR
39 NtfsGetNextPathElement(PWCHAR FileName)
40 {
41 if (*FileName == L'\0')
42 {
43 return NULL;
44 }
45
46 while (*FileName != L'\0' && *FileName != L'\\')
47 {
48 FileName++;
49 }
50
51 return FileName;
52 }
53
54
55 static
56 VOID
57 NtfsWSubString(PWCHAR pTarget,
58 const PWCHAR pSource,
59 size_t pLength)
60 {
61 wcsncpy(pTarget, pSource, pLength);
62 pTarget[pLength] = L'\0';
63 }
64
65
66 PNTFS_FCB
67 NtfsCreateFCB(PCWSTR FileName,
68 PCWSTR Stream,
69 PNTFS_VCB Vcb)
70 {
71 PNTFS_FCB Fcb;
72
73 ASSERT(Vcb);
74 ASSERT(Vcb->Identifier.Type == NTFS_TYPE_VCB);
75
76 Fcb = ExAllocateFromNPagedLookasideList(&NtfsGlobalData->FcbLookasideList);
77 RtlZeroMemory(Fcb, sizeof(NTFS_FCB));
78
79 Fcb->Identifier.Type = NTFS_TYPE_FCB;
80 Fcb->Identifier.Size = sizeof(NTFS_TYPE_FCB);
81
82 Fcb->Vcb = Vcb;
83
84 if (FileName)
85 {
86 wcscpy(Fcb->PathName, FileName);
87 if (wcsrchr(Fcb->PathName, '\\') != 0)
88 {
89 Fcb->ObjectName = wcsrchr(Fcb->PathName, '\\');
90 }
91 else
92 {
93 Fcb->ObjectName = Fcb->PathName;
94 }
95 }
96
97 if (Stream)
98 {
99 wcscpy(Fcb->Stream, Stream);
100 }
101 else
102 {
103 Fcb->Stream[0] = UNICODE_NULL;
104 }
105
106 ExInitializeResourceLite(&Fcb->MainResource);
107
108 Fcb->RFCB.Resource = &(Fcb->MainResource);
109
110 return Fcb;
111 }
112
113
114 VOID
115 NtfsDestroyFCB(PNTFS_FCB Fcb)
116 {
117 ASSERT(Fcb);
118 ASSERT(Fcb->Identifier.Type == NTFS_TYPE_FCB);
119
120 ExDeleteResourceLite(&Fcb->MainResource);
121
122 ExFreeToNPagedLookasideList(&NtfsGlobalData->FcbLookasideList, Fcb);
123 }
124
125
126 BOOLEAN
127 NtfsFCBIsDirectory(PNTFS_FCB Fcb)
128 {
129 return ((Fcb->Entry.FileAttributes & NTFS_FILE_TYPE_DIRECTORY) == NTFS_FILE_TYPE_DIRECTORY);
130 }
131
132
133 BOOLEAN
134 NtfsFCBIsReparsePoint(PNTFS_FCB Fcb)
135 {
136 return ((Fcb->Entry.FileAttributes & NTFS_FILE_TYPE_REPARSE) == NTFS_FILE_TYPE_REPARSE);
137 }
138
139
140 BOOLEAN
141 NtfsFCBIsCompressed(PNTFS_FCB Fcb)
142 {
143 return ((Fcb->Entry.FileAttributes & NTFS_FILE_TYPE_COMPRESSED) == NTFS_FILE_TYPE_COMPRESSED);
144 }
145
146 BOOLEAN
147 NtfsFCBIsRoot(PNTFS_FCB Fcb)
148 {
149 return (wcscmp(Fcb->PathName, L"\\") == 0);
150 }
151
152
153 VOID
154 NtfsGrabFCB(PNTFS_VCB Vcb,
155 PNTFS_FCB Fcb)
156 {
157 KIRQL oldIrql;
158
159 DPRINT("grabbing FCB at %p: %S, refCount:%d\n",
160 Fcb,
161 Fcb->PathName,
162 Fcb->RefCount);
163
164 KeAcquireSpinLock(&Vcb->FcbListLock, &oldIrql);
165 Fcb->RefCount++;
166 KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
167 }
168
169
170 VOID
171 NtfsReleaseFCB(PNTFS_VCB Vcb,
172 PNTFS_FCB Fcb)
173 {
174 KIRQL oldIrql;
175
176 DPRINT("releasing FCB at %p: %S, refCount:%d\n",
177 Fcb,
178 Fcb->PathName,
179 Fcb->RefCount);
180
181 KeAcquireSpinLock(&Vcb->FcbListLock, &oldIrql);
182 Fcb->RefCount--;
183 if (Fcb->RefCount <= 0 && !NtfsFCBIsDirectory(Fcb))
184 {
185 RemoveEntryList(&Fcb->FcbListEntry);
186 KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
187 CcUninitializeCacheMap(Fcb->FileObject, NULL, NULL);
188 NtfsDestroyFCB(Fcb);
189 }
190 else
191 {
192 KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
193 }
194 }
195
196
197 VOID
198 NtfsAddFCBToTable(PNTFS_VCB Vcb,
199 PNTFS_FCB Fcb)
200 {
201 KIRQL oldIrql;
202
203 KeAcquireSpinLock(&Vcb->FcbListLock, &oldIrql);
204 Fcb->Vcb = Vcb;
205 InsertTailList(&Vcb->FcbListHead, &Fcb->FcbListEntry);
206 KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
207 }
208
209
210 PNTFS_FCB
211 NtfsGrabFCBFromTable(PNTFS_VCB Vcb,
212 PCWSTR FileName)
213 {
214 KIRQL oldIrql;
215 PNTFS_FCB Fcb;
216 PLIST_ENTRY current_entry;
217
218 KeAcquireSpinLock(&Vcb->FcbListLock, &oldIrql);
219
220 if (FileName == NULL || *FileName == 0)
221 {
222 DPRINT("Return FCB for stream file object\n");
223 Fcb = Vcb->StreamFileObject->FsContext;
224 Fcb->RefCount++;
225 KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
226 return Fcb;
227 }
228
229 current_entry = Vcb->FcbListHead.Flink;
230 while (current_entry != &Vcb->FcbListHead)
231 {
232 Fcb = CONTAINING_RECORD(current_entry, NTFS_FCB, FcbListEntry);
233
234 DPRINT("Comparing '%S' and '%S'\n", FileName, Fcb->PathName);
235 if (_wcsicmp(FileName, Fcb->PathName) == 0)
236 {
237 Fcb->RefCount++;
238 KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
239 return Fcb;
240 }
241
242 //FIXME: need to compare against short name in FCB here
243
244 current_entry = current_entry->Flink;
245 }
246
247 KeReleaseSpinLock(&Vcb->FcbListLock, oldIrql);
248
249 return NULL;
250 }
251
252
253 NTSTATUS
254 NtfsFCBInitializeCache(PNTFS_VCB Vcb,
255 PNTFS_FCB Fcb)
256 {
257 PFILE_OBJECT FileObject;
258 NTSTATUS Status;
259 PNTFS_CCB newCCB;
260
261 FileObject = IoCreateStreamFileObject(NULL, Vcb->StorageDevice);
262
263 newCCB = ExAllocatePoolWithTag(NonPagedPool, sizeof(NTFS_CCB), TAG_CCB);
264 if (newCCB == NULL)
265 {
266 return STATUS_INSUFFICIENT_RESOURCES;
267 }
268
269 RtlZeroMemory(newCCB, sizeof(NTFS_CCB));
270
271 newCCB->Identifier.Type = NTFS_TYPE_CCB;
272 newCCB->Identifier.Size = sizeof(NTFS_TYPE_CCB);
273
274 FileObject->SectionObjectPointer = &Fcb->SectionObjectPointers;
275 FileObject->FsContext = Fcb;
276 FileObject->FsContext2 = newCCB;
277 newCCB->PtrFileObject = FileObject;
278 Fcb->FileObject = FileObject;
279 Fcb->Vcb = Vcb;
280
281 Status = STATUS_SUCCESS;
282 _SEH2_TRY
283 {
284 CcInitializeCacheMap(FileObject,
285 (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
286 FALSE,
287 &(NtfsGlobalData->CacheMgrCallbacks),
288 Fcb);
289 }
290 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
291 {
292 FileObject->FsContext2 = NULL;
293 ExFreePoolWithTag(newCCB, TAG_CCB);
294 ObDereferenceObject(FileObject);
295 Fcb->FileObject = NULL;
296 return _SEH2_GetExceptionCode();
297 }
298 _SEH2_END;
299
300 ObDereferenceObject(FileObject);
301 Fcb->Flags |= FCB_CACHE_INITIALIZED;
302
303 return Status;
304 }
305
306
307 PNTFS_FCB
308 NtfsMakeRootFCB(PNTFS_VCB Vcb)
309 {
310 PNTFS_FCB Fcb;
311 PFILE_RECORD_HEADER MftRecord;
312 PFILENAME_ATTRIBUTE FileName;
313
314 MftRecord = ExAllocatePoolWithTag(NonPagedPool,
315 Vcb->NtfsInfo.BytesPerFileRecord,
316 TAG_NTFS);
317 if (MftRecord == NULL)
318 {
319 return NULL;
320 }
321
322 if (!NT_SUCCESS(ReadFileRecord(Vcb, NTFS_FILE_ROOT, MftRecord)))
323 {
324 ExFreePoolWithTag(MftRecord, TAG_NTFS);
325 return NULL;
326 }
327
328 FileName = GetFileNameFromRecord(Vcb, MftRecord, NTFS_FILE_NAME_WIN32);
329 if (!FileName)
330 {
331 ExFreePoolWithTag(MftRecord, TAG_NTFS);
332 return NULL;
333 }
334
335 Fcb = NtfsCreateFCB(L"\\", NULL, Vcb);
336 if (!Fcb)
337 {
338 ExFreePoolWithTag(MftRecord, TAG_NTFS);
339 return NULL;
340 }
341
342 memcpy(&Fcb->Entry, FileName, FIELD_OFFSET(FILENAME_ATTRIBUTE, NameLength));
343 Fcb->Entry.NameType = FileName->NameType;
344 Fcb->Entry.NameLength = 0;
345 Fcb->Entry.Name[0] = UNICODE_NULL;
346 Fcb->RefCount = 1;
347 Fcb->DirIndex = 0;
348 Fcb->RFCB.FileSize.QuadPart = FileName->DataSize;
349 Fcb->RFCB.ValidDataLength.QuadPart = FileName->DataSize;
350 Fcb->RFCB.AllocationSize.QuadPart = FileName->AllocatedSize;
351 Fcb->MFTIndex = NTFS_FILE_ROOT;
352 Fcb->LinkCount = MftRecord->LinkCount;
353
354 NtfsFCBInitializeCache(Vcb, Fcb);
355 NtfsAddFCBToTable(Vcb, Fcb);
356 NtfsGrabFCB(Vcb, Fcb);
357
358 ExFreePoolWithTag(MftRecord, TAG_NTFS);
359
360 return Fcb;
361 }
362
363
364 PNTFS_FCB
365 NtfsOpenRootFCB(PNTFS_VCB Vcb)
366 {
367 PNTFS_FCB Fcb;
368
369 Fcb = NtfsGrabFCBFromTable(Vcb, L"\\");
370 if (Fcb == NULL)
371 {
372 Fcb = NtfsMakeRootFCB(Vcb);
373 }
374
375 return Fcb;
376 }
377
378
379 NTSTATUS
380 NtfsMakeFCBFromDirEntry(PNTFS_VCB Vcb,
381 PNTFS_FCB DirectoryFCB,
382 PUNICODE_STRING Name,
383 PCWSTR Stream,
384 PFILE_RECORD_HEADER Record,
385 ULONGLONG MFTIndex,
386 PNTFS_FCB * fileFCB)
387 {
388 WCHAR pathName[MAX_PATH];
389 PFILENAME_ATTRIBUTE FileName;
390 PSTANDARD_INFORMATION StdInfo;
391 PNTFS_FCB rcFCB;
392 ULONGLONG Size, AllocatedSize;
393
394 DPRINT1("NtfsMakeFCBFromDirEntry(%p, %p, %wZ, %p, %p, %p)\n", Vcb, DirectoryFCB, Name, Stream, Record, fileFCB);
395
396 FileName = GetBestFileNameFromRecord(Vcb, Record);
397 if (!FileName)
398 {
399 return STATUS_OBJECT_NAME_NOT_FOUND; // Not sure that's the best here
400 }
401
402 if (DirectoryFCB && Name)
403 {
404 if (Name->Buffer[0] != 0 && wcslen(DirectoryFCB->PathName) +
405 sizeof(WCHAR) + Name->Length / sizeof(WCHAR) > MAX_PATH)
406 {
407 return STATUS_OBJECT_NAME_INVALID;
408 }
409
410 wcscpy(pathName, DirectoryFCB->PathName);
411 if (!NtfsFCBIsRoot(DirectoryFCB))
412 {
413 wcscat(pathName, L"\\");
414 }
415 wcscat(pathName, Name->Buffer);
416 }
417 else
418 {
419 RtlCopyMemory(pathName, FileName->Name, FileName->NameLength * sizeof (WCHAR));
420 pathName[FileName->NameLength] = UNICODE_NULL;
421 }
422
423 Size = NtfsGetFileSize(Vcb, Record, (Stream ? Stream : L""), (Stream ? wcslen(Stream) : 0), &AllocatedSize);
424
425 rcFCB = NtfsCreateFCB(pathName, Stream, Vcb);
426 if (!rcFCB)
427 {
428 return STATUS_INSUFFICIENT_RESOURCES;
429 }
430
431 memcpy(&rcFCB->Entry, FileName, FIELD_OFFSET(FILENAME_ATTRIBUTE, NameLength));
432 rcFCB->Entry.NameType = FileName->NameType;
433 rcFCB->RFCB.FileSize.QuadPart = Size;
434 rcFCB->RFCB.ValidDataLength.QuadPart = Size;
435 rcFCB->RFCB.AllocationSize.QuadPart = AllocatedSize;
436
437 StdInfo = GetStandardInformationFromRecord(Vcb, Record);
438 if (StdInfo != NULL)
439 {
440 rcFCB->Entry.FileAttributes |= StdInfo->FileAttribute;
441 }
442
443 NtfsFCBInitializeCache(Vcb, rcFCB);
444 rcFCB->RefCount = 1;
445 rcFCB->MFTIndex = MFTIndex;
446 rcFCB->LinkCount = Record->LinkCount;
447 NtfsAddFCBToTable(Vcb, rcFCB);
448 *fileFCB = rcFCB;
449
450 return STATUS_SUCCESS;
451 }
452
453
454 NTSTATUS
455 NtfsAttachFCBToFileObject(PNTFS_VCB Vcb,
456 PNTFS_FCB Fcb,
457 PFILE_OBJECT FileObject)
458 {
459 PNTFS_CCB newCCB;
460
461 newCCB = ExAllocatePoolWithTag(NonPagedPool, sizeof(NTFS_CCB), TAG_CCB);
462 if (newCCB == NULL)
463 {
464 return STATUS_INSUFFICIENT_RESOURCES;
465 }
466
467 RtlZeroMemory(newCCB, sizeof(NTFS_CCB));
468
469 newCCB->Identifier.Type = NTFS_TYPE_CCB;
470 newCCB->Identifier.Size = sizeof(NTFS_TYPE_CCB);
471
472 FileObject->SectionObjectPointer = &Fcb->SectionObjectPointers;
473 FileObject->FsContext = Fcb;
474 FileObject->FsContext2 = newCCB;
475 newCCB->PtrFileObject = FileObject;
476 Fcb->Vcb = Vcb;
477
478 if (!(Fcb->Flags & FCB_CACHE_INITIALIZED))
479 {
480 _SEH2_TRY
481 {
482 CcInitializeCacheMap(FileObject,
483 (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
484 FALSE,
485 &(NtfsGlobalData->CacheMgrCallbacks),
486 Fcb);
487 }
488 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
489 {
490 FileObject->FsContext2 = NULL;
491 ExFreePoolWithTag(newCCB, TAG_CCB);
492 return _SEH2_GetExceptionCode();
493 }
494 _SEH2_END;
495
496 Fcb->Flags |= FCB_CACHE_INITIALIZED;
497 }
498
499 //DPRINT("file open: fcb:%x file size: %d\n", Fcb, Fcb->Entry.DataLengthL);
500
501 return STATUS_SUCCESS;
502 }
503
504
505 static NTSTATUS
506 NtfsDirFindFile(PNTFS_VCB Vcb,
507 PNTFS_FCB DirectoryFcb,
508 PWSTR FileToFind,
509 PNTFS_FCB *FoundFCB)
510 {
511 NTSTATUS Status;
512 ULONGLONG CurrentDir;
513 UNICODE_STRING File;
514 PFILE_RECORD_HEADER FileRecord;
515 ULONGLONG MFTIndex;
516 PWSTR Colon, OldColon;
517 PNTFS_ATTR_CONTEXT DataContext;
518 USHORT Length = 0;
519
520 DPRINT1("NtfsDirFindFile(%p, %p, %S, %p)\n", Vcb, DirectoryFcb, FileToFind, FoundFCB);
521
522 *FoundFCB = NULL;
523 RtlInitUnicodeString(&File, FileToFind);
524 CurrentDir = DirectoryFcb->MFTIndex;
525
526 Colon = wcsrchr(FileToFind, L':');
527 if (Colon != NULL)
528 {
529 Length = File.Length;
530 File.Length = (Colon - FileToFind) * sizeof(WCHAR);
531
532 if (_wcsicmp(Colon + 1, L"$DATA") == 0)
533 {
534 OldColon = Colon;
535 Colon[0] = UNICODE_NULL;
536 Colon = wcsrchr(FileToFind, L':');
537 if (Colon != NULL)
538 {
539 Length = File.Length;
540 File.Length = (Colon - FileToFind) * sizeof(WCHAR);
541 }
542 else
543 {
544 Colon = OldColon;
545 Colon[0] = L':';
546 }
547 }
548
549 /* Skip colon */
550 ++Colon;
551 DPRINT1("Will now look for file '%wZ' with stream '%S'\n", &File, Colon);
552 }
553
554 Status = NtfsLookupFileAt(Vcb, &File, &FileRecord, &MFTIndex, CurrentDir);
555 if (!NT_SUCCESS(Status))
556 {
557 return Status;
558 }
559
560 if (Length != 0)
561 {
562 File.Length = Length;
563 }
564
565 if ((FileRecord->Flags & FRH_DIRECTORY) && Colon != 0)
566 {
567 return STATUS_INVALID_PARAMETER;
568 }
569 else if (Colon != 0)
570 {
571 Status = FindAttribute(Vcb, FileRecord, AttributeData, Colon, wcslen(Colon), &DataContext);
572 if (!NT_SUCCESS(Status))
573 {
574 return STATUS_OBJECT_NAME_NOT_FOUND;
575 }
576 ReleaseAttributeContext(DataContext);
577 }
578
579 Status = NtfsMakeFCBFromDirEntry(Vcb, DirectoryFcb, &File, Colon, FileRecord, MFTIndex, FoundFCB);
580 ExFreePoolWithTag(FileRecord, TAG_NTFS);
581
582 return Status;
583 }
584
585
586 NTSTATUS
587 NtfsGetFCBForFile(PNTFS_VCB Vcb,
588 PNTFS_FCB *pParentFCB,
589 PNTFS_FCB *pFCB,
590 const PWSTR pFileName)
591 {
592 NTSTATUS Status;
593 WCHAR pathName [MAX_PATH];
594 WCHAR elementName [MAX_PATH];
595 PWCHAR currentElement;
596 PNTFS_FCB FCB;
597 PNTFS_FCB parentFCB;
598
599 DPRINT("NtfsGetFCBForFile(%p, %p, %p, '%S')\n",
600 Vcb,
601 pParentFCB,
602 pFCB,
603 pFileName);
604
605 /* Dummy code */
606 // FCB = NtfsOpenRootFCB(Vcb);
607 // *pFCB = FCB;
608 // *pParentFCB = NULL;
609
610 #if 1
611 /* Trivial case, open of the root directory on volume */
612 if (pFileName [0] == L'\0' || wcscmp(pFileName, L"\\") == 0)
613 {
614 DPRINT("returning root FCB\n");
615
616 FCB = NtfsOpenRootFCB(Vcb);
617 *pFCB = FCB;
618 *pParentFCB = NULL;
619
620 return (FCB != NULL) ? STATUS_SUCCESS : STATUS_OBJECT_PATH_NOT_FOUND;
621 }
622 else
623 {
624 currentElement = pFileName + 1;
625 wcscpy (pathName, L"\\");
626 FCB = NtfsOpenRootFCB (Vcb);
627 }
628
629 parentFCB = NULL;
630
631 /* Parse filename and check each path element for existence and access */
632 while (NtfsGetNextPathElement(currentElement) != 0)
633 {
634 /* Skip blank directory levels */
635 if ((NtfsGetNextPathElement(currentElement) - currentElement) == 0)
636 {
637 currentElement++;
638 continue;
639 }
640
641 DPRINT("Parsing, currentElement:%S\n", currentElement);
642 DPRINT(" parentFCB:%p FCB:%p\n", parentFCB, FCB);
643
644 /* Descend to next directory level */
645 if (parentFCB)
646 {
647 NtfsReleaseFCB(Vcb, parentFCB);
648 parentFCB = NULL;
649 }
650
651 /* fail if element in FCB is not a directory */
652 if (!NtfsFCBIsDirectory(FCB))
653 {
654 DPRINT("Element in requested path is not a directory\n");
655
656 NtfsReleaseFCB(Vcb, FCB);
657 FCB = 0;
658 *pParentFCB = NULL;
659 *pFCB = NULL;
660
661 return STATUS_OBJECT_PATH_NOT_FOUND;
662 }
663
664 parentFCB = FCB;
665
666 /* Extract next directory level into dirName */
667 NtfsWSubString(pathName,
668 pFileName,
669 NtfsGetNextPathElement(currentElement) - pFileName);
670 DPRINT(" pathName:%S\n", pathName);
671
672 FCB = NtfsGrabFCBFromTable(Vcb, pathName);
673 if (FCB == NULL)
674 {
675 NtfsWSubString(elementName,
676 currentElement,
677 NtfsGetNextPathElement(currentElement) - currentElement);
678 DPRINT(" elementName:%S\n", elementName);
679
680 Status = NtfsDirFindFile(Vcb, parentFCB, elementName, &FCB);
681 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
682 {
683 *pParentFCB = parentFCB;
684 *pFCB = NULL;
685 currentElement = NtfsGetNextPathElement(currentElement);
686 if (*currentElement == L'\0' || NtfsGetNextPathElement(currentElement + 1) == 0)
687 {
688 return STATUS_OBJECT_NAME_NOT_FOUND;
689 }
690 else
691 {
692 return STATUS_OBJECT_PATH_NOT_FOUND;
693 }
694 }
695 else if (!NT_SUCCESS(Status))
696 {
697 NtfsReleaseFCB(Vcb, parentFCB);
698 *pParentFCB = NULL;
699 *pFCB = NULL;
700
701 return Status;
702 }
703 }
704
705 currentElement = NtfsGetNextPathElement(currentElement);
706 }
707
708 *pParentFCB = parentFCB;
709 *pFCB = FCB;
710 #endif
711
712 return STATUS_SUCCESS;
713 }
714
715
716 NTSTATUS
717 NtfsReadFCBAttribute(PNTFS_VCB Vcb,
718 PNTFS_FCB pFCB,
719 ULONG Type,
720 PCWSTR Name,
721 ULONG NameLength,
722 PVOID * Data)
723 {
724 NTSTATUS Status;
725 PFILE_RECORD_HEADER FileRecord;
726 PNTFS_ATTR_CONTEXT AttrCtxt;
727 ULONGLONG AttrLength;
728
729 FileRecord = ExAllocatePoolWithTag(NonPagedPool,
730 Vcb->NtfsInfo.BytesPerFileRecord,
731 TAG_NTFS);
732 if (FileRecord == NULL)
733 {
734 return STATUS_INSUFFICIENT_RESOURCES;
735 }
736
737 Status = ReadFileRecord(Vcb, pFCB->MFTIndex, FileRecord);
738 if (!NT_SUCCESS(Status))
739 {
740 ExFreePoolWithTag(FileRecord, TAG_NTFS);
741 return Status;
742 }
743
744 Status = FindAttribute(Vcb, FileRecord, Type, Name, NameLength, &AttrCtxt);
745 if (!NT_SUCCESS(Status))
746 {
747 ExFreePoolWithTag(FileRecord, TAG_NTFS);
748 return Status;
749 }
750
751 AttrLength = AttributeDataLength(&AttrCtxt->Record);
752 *Data = ExAllocatePoolWithTag(NonPagedPool, AttrLength, TAG_NTFS);
753 if (*Data == NULL)
754 {
755 ReleaseAttributeContext(AttrCtxt);
756 ExFreePoolWithTag(FileRecord, TAG_NTFS);
757 return STATUS_INSUFFICIENT_RESOURCES;
758 }
759
760 ReadAttribute(Vcb, AttrCtxt, 0, *Data, AttrLength);
761
762 ReleaseAttributeContext(AttrCtxt);
763 ExFreePoolWithTag(FileRecord, TAG_NTFS);
764
765 return STATUS_SUCCESS;
766 }
767
768 /* EOF */