[FASTFAT] Fix size checking in VfatGetFileNameInformation()
[reactos.git] / drivers / filesystems / fastfat / finfo.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: drivers/filesystems/fastfat/finfo.c
5 * PURPOSE: VFAT Filesystem
6 * PROGRAMMER: Jason Filby (jasonfilby@yahoo.com)
7 * Herve Poussineau (reactos@poussine.freesurf.fr)
8 * Pierre Schweitzer (pierre@reactos.org)
9 *
10 */
11
12 /* INCLUDES *****************************************************************/
13
14 #include "vfat.h"
15
16 #define NDEBUG
17 #include <debug.h>
18
19 #define NASSERTS_RENAME
20
21 /* GLOBALS ******************************************************************/
22
23 const char* FileInformationClassNames[] =
24 {
25 "??????",
26 "FileDirectoryInformation",
27 "FileFullDirectoryInformation",
28 "FileBothDirectoryInformation",
29 "FileBasicInformation",
30 "FileStandardInformation",
31 "FileInternalInformation",
32 "FileEaInformation",
33 "FileAccessInformation",
34 "FileNameInformation",
35 "FileRenameInformation",
36 "FileLinkInformation",
37 "FileNamesInformation",
38 "FileDispositionInformation",
39 "FilePositionInformation",
40 "FileFullEaInformation",
41 "FileModeInformation",
42 "FileAlignmentInformation",
43 "FileAllInformation",
44 "FileAllocationInformation",
45 "FileEndOfFileInformation",
46 "FileAlternateNameInformation",
47 "FileStreamInformation",
48 "FilePipeInformation",
49 "FilePipeLocalInformation",
50 "FilePipeRemoteInformation",
51 "FileMailslotQueryInformation",
52 "FileMailslotSetInformation",
53 "FileCompressionInformation",
54 "FileObjectIdInformation",
55 "FileCompletionInformation",
56 "FileMoveClusterInformation",
57 "FileQuotaInformation",
58 "FileReparsePointInformation",
59 "FileNetworkOpenInformation",
60 "FileAttributeTagInformation",
61 "FileTrackingInformation",
62 "FileIdBothDirectoryInformation",
63 "FileIdFullDirectoryInformation",
64 "FileValidDataLengthInformation",
65 "FileShortNameInformation",
66 "FileMaximumInformation"
67 };
68
69 /* FUNCTIONS ****************************************************************/
70
71 /*
72 * FUNCTION: Retrieve the standard file information
73 */
74 NTSTATUS
75 VfatGetStandardInformation(
76 PVFATFCB FCB,
77 PFILE_STANDARD_INFORMATION StandardInfo,
78 PULONG BufferLength)
79 {
80 if (*BufferLength < sizeof(FILE_STANDARD_INFORMATION))
81 return STATUS_BUFFER_OVERFLOW;
82
83 /* PRECONDITION */
84 ASSERT(StandardInfo != NULL);
85 ASSERT(FCB != NULL);
86
87 if (vfatFCBIsDirectory(FCB))
88 {
89 StandardInfo->AllocationSize.QuadPart = 0;
90 StandardInfo->EndOfFile.QuadPart = 0;
91 StandardInfo->Directory = TRUE;
92 }
93 else
94 {
95 StandardInfo->AllocationSize = FCB->RFCB.AllocationSize;
96 StandardInfo->EndOfFile = FCB->RFCB.FileSize;
97 StandardInfo->Directory = FALSE;
98 }
99 StandardInfo->NumberOfLinks = 1;
100 StandardInfo->DeletePending = BooleanFlagOn(FCB->Flags, FCB_DELETE_PENDING);
101
102 *BufferLength -= sizeof(FILE_STANDARD_INFORMATION);
103 return STATUS_SUCCESS;
104 }
105
106 static
107 NTSTATUS
108 VfatSetPositionInformation(
109 PFILE_OBJECT FileObject,
110 PFILE_POSITION_INFORMATION PositionInfo)
111 {
112 DPRINT("FsdSetPositionInformation()\n");
113
114 DPRINT("PositionInfo %p\n", PositionInfo);
115 DPRINT("Setting position %u\n", PositionInfo->CurrentByteOffset.u.LowPart);
116
117 FileObject->CurrentByteOffset.QuadPart =
118 PositionInfo->CurrentByteOffset.QuadPart;
119
120 return STATUS_SUCCESS;
121 }
122
123 static
124 NTSTATUS
125 VfatGetPositionInformation(
126 PFILE_OBJECT FileObject,
127 PVFATFCB FCB,
128 PDEVICE_EXTENSION DeviceExt,
129 PFILE_POSITION_INFORMATION PositionInfo,
130 PULONG BufferLength)
131 {
132 UNREFERENCED_PARAMETER(FileObject);
133 UNREFERENCED_PARAMETER(FCB);
134 UNREFERENCED_PARAMETER(DeviceExt);
135
136 DPRINT("VfatGetPositionInformation()\n");
137
138 if (*BufferLength < sizeof(FILE_POSITION_INFORMATION))
139 return STATUS_BUFFER_OVERFLOW;
140
141 PositionInfo->CurrentByteOffset.QuadPart =
142 FileObject->CurrentByteOffset.QuadPart;
143
144 DPRINT("Getting position %I64x\n",
145 PositionInfo->CurrentByteOffset.QuadPart);
146
147 *BufferLength -= sizeof(FILE_POSITION_INFORMATION);
148 return STATUS_SUCCESS;
149 }
150
151 static
152 NTSTATUS
153 VfatSetBasicInformation(
154 PFILE_OBJECT FileObject,
155 PVFATFCB FCB,
156 PDEVICE_EXTENSION DeviceExt,
157 PFILE_BASIC_INFORMATION BasicInfo)
158 {
159 ULONG NotifyFilter;
160
161 DPRINT("VfatSetBasicInformation()\n");
162
163 ASSERT(NULL != FileObject);
164 ASSERT(NULL != FCB);
165 ASSERT(NULL != DeviceExt);
166 ASSERT(NULL != BasicInfo);
167 /* Check volume label bit */
168 ASSERT(0 == (*FCB->Attributes & _A_VOLID));
169
170 NotifyFilter = 0;
171
172 if (BasicInfo->FileAttributes != 0)
173 {
174 UCHAR Attributes;
175
176 Attributes = (BasicInfo->FileAttributes & (FILE_ATTRIBUTE_ARCHIVE |
177 FILE_ATTRIBUTE_SYSTEM |
178 FILE_ATTRIBUTE_HIDDEN |
179 FILE_ATTRIBUTE_DIRECTORY |
180 FILE_ATTRIBUTE_READONLY));
181
182 if (vfatFCBIsDirectory(FCB))
183 {
184 if (BooleanFlagOn(BasicInfo->FileAttributes, FILE_ATTRIBUTE_TEMPORARY))
185 {
186 DPRINT("Setting temporary attribute on a directory!\n");
187 return STATUS_INVALID_PARAMETER;
188 }
189
190 Attributes |= FILE_ATTRIBUTE_DIRECTORY;
191 }
192 else
193 {
194 if (BooleanFlagOn(BasicInfo->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
195 {
196 DPRINT("Setting directory attribute on a file!\n");
197 return STATUS_INVALID_PARAMETER;
198 }
199 }
200
201 if (Attributes != *FCB->Attributes)
202 {
203 *FCB->Attributes = Attributes;
204 DPRINT("Setting attributes 0x%02x\n", *FCB->Attributes);
205 NotifyFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
206 }
207 }
208
209 if (vfatVolumeIsFatX(DeviceExt))
210 {
211 if (BasicInfo->CreationTime.QuadPart != 0 && BasicInfo->CreationTime.QuadPart != -1)
212 {
213 FsdSystemTimeToDosDateTime(DeviceExt,
214 &BasicInfo->CreationTime,
215 &FCB->entry.FatX.CreationDate,
216 &FCB->entry.FatX.CreationTime);
217 NotifyFilter |= FILE_NOTIFY_CHANGE_CREATION;
218 }
219
220 if (BasicInfo->LastAccessTime.QuadPart != 0 && BasicInfo->LastAccessTime.QuadPart != -1)
221 {
222 FsdSystemTimeToDosDateTime(DeviceExt,
223 &BasicInfo->LastAccessTime,
224 &FCB->entry.FatX.AccessDate,
225 &FCB->entry.FatX.AccessTime);
226 NotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
227 }
228
229 if (BasicInfo->LastWriteTime.QuadPart != 0 && BasicInfo->LastWriteTime.QuadPart != -1)
230 {
231 FsdSystemTimeToDosDateTime(DeviceExt,
232 &BasicInfo->LastWriteTime,
233 &FCB->entry.FatX.UpdateDate,
234 &FCB->entry.FatX.UpdateTime);
235 NotifyFilter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
236 }
237 }
238 else
239 {
240 if (BasicInfo->CreationTime.QuadPart != 0 && BasicInfo->CreationTime.QuadPart != -1)
241 {
242 FsdSystemTimeToDosDateTime(DeviceExt,
243 &BasicInfo->CreationTime,
244 &FCB->entry.Fat.CreationDate,
245 &FCB->entry.Fat.CreationTime);
246 NotifyFilter |= FILE_NOTIFY_CHANGE_CREATION;
247 }
248
249 if (BasicInfo->LastAccessTime.QuadPart != 0 && BasicInfo->LastAccessTime.QuadPart != -1)
250 {
251 FsdSystemTimeToDosDateTime(DeviceExt,
252 &BasicInfo->LastAccessTime,
253 &FCB->entry.Fat.AccessDate,
254 NULL);
255 NotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
256 }
257
258 if (BasicInfo->LastWriteTime.QuadPart != 0 && BasicInfo->LastWriteTime.QuadPart != -1)
259 {
260 FsdSystemTimeToDosDateTime(DeviceExt,
261 &BasicInfo->LastWriteTime,
262 &FCB->entry.Fat.UpdateDate,
263 &FCB->entry.Fat.UpdateTime);
264 NotifyFilter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
265 }
266 }
267
268 VfatUpdateEntry(FCB, vfatVolumeIsFatX(DeviceExt));
269
270 if (NotifyFilter != 0)
271 {
272 FsRtlNotifyFullReportChange(DeviceExt->NotifySync,
273 &(DeviceExt->NotifyList),
274 (PSTRING)&FCB->PathNameU,
275 FCB->PathNameU.Length - FCB->LongNameU.Length,
276 NULL, NULL, NotifyFilter, FILE_ACTION_MODIFIED,
277 NULL);
278 }
279
280 return STATUS_SUCCESS;
281 }
282
283 NTSTATUS
284 VfatGetBasicInformation(
285 PFILE_OBJECT FileObject,
286 PVFATFCB FCB,
287 PDEVICE_EXTENSION DeviceExt,
288 PFILE_BASIC_INFORMATION BasicInfo,
289 PULONG BufferLength)
290 {
291 UNREFERENCED_PARAMETER(FileObject);
292
293 DPRINT("VfatGetBasicInformation()\n");
294
295 if (*BufferLength < sizeof(FILE_BASIC_INFORMATION))
296 return STATUS_BUFFER_OVERFLOW;
297
298 if (vfatVolumeIsFatX(DeviceExt))
299 {
300 FsdDosDateTimeToSystemTime(DeviceExt,
301 FCB->entry.FatX.CreationDate,
302 FCB->entry.FatX.CreationTime,
303 &BasicInfo->CreationTime);
304 FsdDosDateTimeToSystemTime(DeviceExt,
305 FCB->entry.FatX.AccessDate,
306 FCB->entry.FatX.AccessTime,
307 &BasicInfo->LastAccessTime);
308 FsdDosDateTimeToSystemTime(DeviceExt,
309 FCB->entry.FatX.UpdateDate,
310 FCB->entry.FatX.UpdateTime,
311 &BasicInfo->LastWriteTime);
312 BasicInfo->ChangeTime = BasicInfo->LastWriteTime;
313 }
314 else
315 {
316 FsdDosDateTimeToSystemTime(DeviceExt,
317 FCB->entry.Fat.CreationDate,
318 FCB->entry.Fat.CreationTime,
319 &BasicInfo->CreationTime);
320 FsdDosDateTimeToSystemTime(DeviceExt,
321 FCB->entry.Fat.AccessDate,
322 0,
323 &BasicInfo->LastAccessTime);
324 FsdDosDateTimeToSystemTime(DeviceExt,
325 FCB->entry.Fat.UpdateDate,
326 FCB->entry.Fat.UpdateTime,
327 &BasicInfo->LastWriteTime);
328 BasicInfo->ChangeTime = BasicInfo->LastWriteTime;
329 }
330
331 BasicInfo->FileAttributes = *FCB->Attributes & 0x3f;
332 /* Synthesize FILE_ATTRIBUTE_NORMAL */
333 if (0 == (BasicInfo->FileAttributes & (FILE_ATTRIBUTE_DIRECTORY |
334 FILE_ATTRIBUTE_ARCHIVE |
335 FILE_ATTRIBUTE_SYSTEM |
336 FILE_ATTRIBUTE_HIDDEN |
337 FILE_ATTRIBUTE_READONLY)))
338 {
339 DPRINT("Synthesizing FILE_ATTRIBUTE_NORMAL\n");
340 BasicInfo->FileAttributes |= FILE_ATTRIBUTE_NORMAL;
341 }
342 DPRINT("Getting attributes 0x%02x\n", BasicInfo->FileAttributes);
343
344 *BufferLength -= sizeof(FILE_BASIC_INFORMATION);
345 return STATUS_SUCCESS;
346 }
347
348
349 static
350 NTSTATUS
351 VfatSetDispositionInformation(
352 PFILE_OBJECT FileObject,
353 PVFATFCB FCB,
354 PDEVICE_EXTENSION DeviceExt,
355 PFILE_DISPOSITION_INFORMATION DispositionInfo)
356 {
357 DPRINT("FsdSetDispositionInformation(<%wZ>, Delete %u)\n", &FCB->PathNameU, DispositionInfo->DeleteFile);
358
359 ASSERT(DeviceExt != NULL);
360 ASSERT(DeviceExt->FatInfo.BytesPerCluster != 0);
361 ASSERT(FCB != NULL);
362
363 if (!DispositionInfo->DeleteFile)
364 {
365 /* undelete the file */
366 FCB->Flags &= ~FCB_DELETE_PENDING;
367 FileObject->DeletePending = FALSE;
368 return STATUS_SUCCESS;
369 }
370
371 if (BooleanFlagOn(FCB->Flags, FCB_DELETE_PENDING))
372 {
373 /* stream already marked for deletion. just update the file object */
374 FileObject->DeletePending = TRUE;
375 return STATUS_SUCCESS;
376 }
377
378 if (vfatFCBIsReadOnly(FCB))
379 {
380 return STATUS_CANNOT_DELETE;
381 }
382
383 if (vfatFCBIsRoot(FCB) ||
384 (FCB->LongNameU.Length == sizeof(WCHAR) && FCB->LongNameU.Buffer[0] == L'.') ||
385 (FCB->LongNameU.Length == 2 * sizeof(WCHAR) && FCB->LongNameU.Buffer[0] == L'.' && FCB->LongNameU.Buffer[1] == L'.'))
386 {
387 /* we cannot delete a '.', '..' or the root directory */
388 return STATUS_ACCESS_DENIED;
389 }
390
391 if (!MmFlushImageSection (FileObject->SectionObjectPointer, MmFlushForDelete))
392 {
393 /* can't delete a file if its mapped into a process */
394
395 DPRINT("MmFlushImageSection returned FALSE\n");
396 return STATUS_CANNOT_DELETE;
397 }
398
399 if (vfatFCBIsDirectory(FCB) && !VfatIsDirectoryEmpty(DeviceExt, FCB))
400 {
401 /* can't delete a non-empty directory */
402
403 return STATUS_DIRECTORY_NOT_EMPTY;
404 }
405
406 /* all good */
407 FCB->Flags |= FCB_DELETE_PENDING;
408 FileObject->DeletePending = TRUE;
409
410 return STATUS_SUCCESS;
411 }
412
413 static NTSTATUS
414 vfatPrepareTargetForRename(
415 IN PDEVICE_EXTENSION DeviceExt,
416 IN PVFATFCB * ParentFCB,
417 IN PUNICODE_STRING NewName,
418 IN BOOLEAN ReplaceIfExists,
419 IN PUNICODE_STRING ParentName,
420 OUT PBOOLEAN Deleted)
421 {
422 NTSTATUS Status;
423 PVFATFCB TargetFcb;
424
425 DPRINT("vfatPrepareTargetForRename(%p, %p, %wZ, %d, %wZ, %p)\n", DeviceExt, ParentFCB, NewName, ReplaceIfExists, ParentName);
426
427 *Deleted = FALSE;
428 /* Try to open target */
429 Status = vfatGetFCBForFile(DeviceExt, ParentFCB, &TargetFcb, NewName);
430 /* If it exists */
431 if (NT_SUCCESS(Status))
432 {
433 DPRINT("Target file %wZ exists. FCB Flags %08x\n", NewName, TargetFcb->Flags);
434 /* Check whether we are allowed to replace */
435 if (ReplaceIfExists)
436 {
437 /* If that's a directory or a read-only file, we're not allowed */
438 if (vfatFCBIsDirectory(TargetFcb) || vfatFCBIsReadOnly(TargetFcb))
439 {
440 DPRINT("And this is a readonly file!\n");
441 vfatReleaseFCB(DeviceExt, *ParentFCB);
442 *ParentFCB = NULL;
443 vfatReleaseFCB(DeviceExt, TargetFcb);
444 return STATUS_OBJECT_NAME_COLLISION;
445 }
446
447
448 /* If we still have a file object, close it. */
449 if (TargetFcb->FileObject)
450 {
451 if (!MmFlushImageSection(TargetFcb->FileObject->SectionObjectPointer, MmFlushForDelete))
452 {
453 DPRINT("MmFlushImageSection failed.\n");
454 vfatReleaseFCB(DeviceExt, *ParentFCB);
455 *ParentFCB = NULL;
456 vfatReleaseFCB(DeviceExt, TargetFcb);
457 return STATUS_ACCESS_DENIED;
458 }
459
460 TargetFcb->FileObject->DeletePending = TRUE;
461 VfatCloseFile(DeviceExt, TargetFcb->FileObject);
462 }
463
464 /* If we are here, ensure the file isn't open by anyone! */
465 if (TargetFcb->OpenHandleCount != 0)
466 {
467 DPRINT("There are still open handles for this file.\n");
468 vfatReleaseFCB(DeviceExt, *ParentFCB);
469 *ParentFCB = NULL;
470 vfatReleaseFCB(DeviceExt, TargetFcb);
471 return STATUS_ACCESS_DENIED;
472 }
473
474 /* Effectively delete old file to allow renaming */
475 DPRINT("Effectively deleting the file.\n");
476 VfatDelEntry(DeviceExt, TargetFcb, NULL);
477 vfatReleaseFCB(DeviceExt, TargetFcb);
478 *Deleted = TRUE;
479 return STATUS_SUCCESS;
480 }
481 else
482 {
483 vfatReleaseFCB(DeviceExt, *ParentFCB);
484 *ParentFCB = NULL;
485 vfatReleaseFCB(DeviceExt, TargetFcb);
486 return STATUS_OBJECT_NAME_COLLISION;
487 }
488 }
489 else if (*ParentFCB != NULL)
490 {
491 return STATUS_SUCCESS;
492 }
493
494 /* Failure */
495 return Status;
496 }
497
498 static
499 BOOLEAN
500 IsThereAChildOpened(PVFATFCB FCB)
501 {
502 PLIST_ENTRY Entry;
503 PVFATFCB VolFCB;
504
505 for (Entry = FCB->ParentListHead.Flink; Entry != &FCB->ParentListHead; Entry = Entry->Flink)
506 {
507 VolFCB = CONTAINING_RECORD(Entry, VFATFCB, ParentListEntry);
508 if (VolFCB->OpenHandleCount != 0)
509 {
510 ASSERT(VolFCB->parentFcb == FCB);
511 DPRINT1("At least one children file opened! %wZ (%u, %u)\n", &VolFCB->PathNameU, VolFCB->RefCount, VolFCB->OpenHandleCount);
512 return TRUE;
513 }
514
515 if (vfatFCBIsDirectory(VolFCB) && !IsListEmpty(&VolFCB->ParentListHead))
516 {
517 if (IsThereAChildOpened(VolFCB))
518 {
519 return TRUE;
520 }
521 }
522 }
523
524 return FALSE;
525 }
526
527 static
528 VOID
529 VfatRenameChildFCB(
530 PDEVICE_EXTENSION DeviceExt,
531 PVFATFCB FCB)
532 {
533 PLIST_ENTRY Entry;
534 PVFATFCB Child;
535
536 if (IsListEmpty(&FCB->ParentListHead))
537 return;
538
539 for (Entry = FCB->ParentListHead.Flink; Entry != &FCB->ParentListHead; Entry = Entry->Flink)
540 {
541 NTSTATUS Status;
542
543 Child = CONTAINING_RECORD(Entry, VFATFCB, ParentListEntry);
544 DPRINT("Found %wZ with still %lu references (parent: %lu)!\n", &Child->PathNameU, Child->RefCount, FCB->RefCount);
545
546 Status = vfatSetFCBNewDirName(DeviceExt, Child, FCB);
547 if (!NT_SUCCESS(Status))
548 continue;
549
550 if (vfatFCBIsDirectory(Child))
551 {
552 VfatRenameChildFCB(DeviceExt, Child);
553 }
554 }
555 }
556
557 /*
558 * FUNCTION: Set the file name information
559 */
560 static
561 NTSTATUS
562 VfatSetRenameInformation(
563 PFILE_OBJECT FileObject,
564 PVFATFCB FCB,
565 PDEVICE_EXTENSION DeviceExt,
566 PFILE_RENAME_INFORMATION RenameInfo,
567 PFILE_OBJECT TargetFileObject)
568 {
569 #ifdef NASSERTS_RENAME
570 #pragma push_macro("ASSERT")
571 #undef ASSERT
572 #define ASSERT(x) ((VOID) 0)
573 #endif
574 NTSTATUS Status;
575 UNICODE_STRING NewName;
576 UNICODE_STRING SourcePath;
577 UNICODE_STRING SourceFile;
578 UNICODE_STRING NewPath;
579 UNICODE_STRING NewFile;
580 PFILE_OBJECT RootFileObject;
581 PVFATFCB RootFCB;
582 UNICODE_STRING RenameInfoString;
583 PVFATFCB ParentFCB;
584 IO_STATUS_BLOCK IoStatusBlock;
585 OBJECT_ATTRIBUTES ObjectAttributes;
586 HANDLE TargetHandle;
587 BOOLEAN DeletedTarget;
588 ULONG OldReferences, NewReferences;
589 PVFATFCB OldParent;
590
591 DPRINT("VfatSetRenameInfo(%p, %p, %p, %p, %p)\n", FileObject, FCB, DeviceExt, RenameInfo, TargetFileObject);
592
593 /* Disallow renaming root */
594 if (vfatFCBIsRoot(FCB))
595 {
596 return STATUS_INVALID_PARAMETER;
597 }
598
599 OldReferences = FCB->parentFcb->RefCount;
600 #ifdef NASSERTS_RENAME
601 UNREFERENCED_PARAMETER(OldReferences);
602 #endif
603
604 /* If we are performing relative opening for rename, get FO for getting FCB and path name */
605 if (RenameInfo->RootDirectory != NULL)
606 {
607 /* We cannot tolerate relative opening with a full path */
608 if (RenameInfo->FileName[0] == L'\\')
609 {
610 return STATUS_OBJECT_NAME_INVALID;
611 }
612
613 Status = ObReferenceObjectByHandle(RenameInfo->RootDirectory,
614 FILE_READ_DATA,
615 *IoFileObjectType,
616 ExGetPreviousMode(),
617 (PVOID *)&RootFileObject,
618 NULL);
619 if (!NT_SUCCESS(Status))
620 {
621 return Status;
622 }
623
624 RootFCB = RootFileObject->FsContext;
625 }
626
627 RtlInitEmptyUnicodeString(&NewName, NULL, 0);
628 ParentFCB = NULL;
629
630 if (TargetFileObject == NULL)
631 {
632 /* If we don't have target file object, construct paths thanks to relative FCB, if any, and with
633 * information supplied by the user
634 */
635
636 /* First, setup a string we'll work on */
637 RenameInfoString.Length = RenameInfo->FileNameLength;
638 RenameInfoString.MaximumLength = RenameInfo->FileNameLength;
639 RenameInfoString.Buffer = RenameInfo->FileName;
640
641 /* Check whether we have FQN */
642 if (RenameInfoString.Length > 6 * sizeof(WCHAR))
643 {
644 if (RenameInfoString.Buffer[0] == L'\\' && RenameInfoString.Buffer[1] == L'?' &&
645 RenameInfoString.Buffer[2] == L'?' && RenameInfoString.Buffer[3] == L'\\' &&
646 RenameInfoString.Buffer[5] == L':' && (RenameInfoString.Buffer[4] >= L'A' &&
647 RenameInfoString.Buffer[4] <= L'Z'))
648 {
649 /* If so, open its target directory */
650 InitializeObjectAttributes(&ObjectAttributes,
651 &RenameInfoString,
652 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
653 NULL, NULL);
654
655 Status = IoCreateFile(&TargetHandle,
656 FILE_WRITE_DATA | SYNCHRONIZE,
657 &ObjectAttributes,
658 &IoStatusBlock,
659 NULL, 0,
660 FILE_SHARE_READ | FILE_SHARE_WRITE,
661 FILE_OPEN,
662 FILE_OPEN_FOR_BACKUP_INTENT,
663 NULL, 0,
664 CreateFileTypeNone,
665 NULL,
666 IO_FORCE_ACCESS_CHECK | IO_OPEN_TARGET_DIRECTORY);
667 if (!NT_SUCCESS(Status))
668 {
669 goto Cleanup;
670 }
671
672 /* Get its FO to get the FCB */
673 Status = ObReferenceObjectByHandle(TargetHandle,
674 FILE_WRITE_DATA,
675 *IoFileObjectType,
676 KernelMode,
677 (PVOID *)&TargetFileObject,
678 NULL);
679 if (!NT_SUCCESS(Status))
680 {
681 ZwClose(TargetHandle);
682 goto Cleanup;
683 }
684
685 /* Are we working on the same volume? */
686 if (IoGetRelatedDeviceObject(TargetFileObject) != IoGetRelatedDeviceObject(FileObject))
687 {
688 ObDereferenceObject(TargetFileObject);
689 ZwClose(TargetHandle);
690 TargetFileObject = NULL;
691 Status = STATUS_NOT_SAME_DEVICE;
692 goto Cleanup;
693 }
694 }
695 }
696
697 NewName.Length = 0;
698 NewName.MaximumLength = RenameInfo->FileNameLength;
699 if (RenameInfo->RootDirectory != NULL)
700 {
701 NewName.MaximumLength += sizeof(WCHAR) + RootFCB->PathNameU.Length;
702 }
703 else if (RenameInfo->FileName[0] != L'\\')
704 {
705 /* We don't have full path, and we don't have root directory:
706 * => we move inside the same directory
707 */
708 NewName.MaximumLength += sizeof(WCHAR) + FCB->DirNameU.Length;
709 }
710 else if (TargetFileObject != NULL)
711 {
712 /* We had a FQN:
713 * => we need to use its correct path
714 */
715 NewName.MaximumLength += sizeof(WCHAR) + ((PVFATFCB)TargetFileObject->FsContext)->PathNameU.Length;
716 }
717
718 NewName.Buffer = ExAllocatePoolWithTag(NonPagedPool, NewName.MaximumLength, TAG_VFAT);
719 if (NewName.Buffer == NULL)
720 {
721 if (TargetFileObject != NULL)
722 {
723 ObDereferenceObject(TargetFileObject);
724 ZwClose(TargetHandle);
725 TargetFileObject = NULL;
726 }
727 Status = STATUS_INSUFFICIENT_RESOURCES;
728 goto Cleanup;
729 }
730
731 if (RenameInfo->RootDirectory != NULL)
732 {
733 /* Here, copy first absolute and then append relative */
734 RtlCopyUnicodeString(&NewName, &RootFCB->PathNameU);
735 NewName.Buffer[NewName.Length / sizeof(WCHAR)] = L'\\';
736 NewName.Length += sizeof(WCHAR);
737 RtlAppendUnicodeStringToString(&NewName, &RenameInfoString);
738 }
739 else if (RenameInfo->FileName[0] != L'\\')
740 {
741 /* Here, copy first work directory and then append filename */
742 RtlCopyUnicodeString(&NewName, &FCB->DirNameU);
743 NewName.Buffer[NewName.Length / sizeof(WCHAR)] = L'\\';
744 NewName.Length += sizeof(WCHAR);
745 RtlAppendUnicodeStringToString(&NewName, &RenameInfoString);
746 }
747 else if (TargetFileObject != NULL)
748 {
749 /* Here, copy first path name and then append filename */
750 RtlCopyUnicodeString(&NewName, &((PVFATFCB)TargetFileObject->FsContext)->PathNameU);
751 NewName.Buffer[NewName.Length / sizeof(WCHAR)] = L'\\';
752 NewName.Length += sizeof(WCHAR);
753 RtlAppendUnicodeStringToString(&NewName, &RenameInfoString);
754 }
755 else
756 {
757 /* Here we should have full path, so simply copy it */
758 RtlCopyUnicodeString(&NewName, &RenameInfoString);
759 }
760
761 /* Do we have to cleanup some stuff? */
762 if (TargetFileObject != NULL)
763 {
764 ObDereferenceObject(TargetFileObject);
765 ZwClose(TargetHandle);
766 TargetFileObject = NULL;
767 }
768 }
769 else
770 {
771 /* At that point, we shouldn't care about whether we are relative opening
772 * Target FO FCB should already have full path
773 */
774
775 /* Before constructing string, just make a sanity check (just to be sure!) */
776 if (IoGetRelatedDeviceObject(TargetFileObject) != IoGetRelatedDeviceObject(FileObject))
777 {
778 Status = STATUS_NOT_SAME_DEVICE;
779 goto Cleanup;
780 }
781
782 NewName.Length = 0;
783 NewName.MaximumLength = TargetFileObject->FileName.Length + ((PVFATFCB)TargetFileObject->FsContext)->PathNameU.Length + sizeof(WCHAR);
784 NewName.Buffer = ExAllocatePoolWithTag(NonPagedPool, NewName.MaximumLength, TAG_VFAT);
785 if (NewName.Buffer == NULL)
786 {
787 Status = STATUS_INSUFFICIENT_RESOURCES;
788 goto Cleanup;
789 }
790
791 RtlCopyUnicodeString(&NewName, &((PVFATFCB)TargetFileObject->FsContext)->PathNameU);
792 NewName.Buffer[NewName.Length / sizeof(WCHAR)] = L'\\';
793 NewName.Length += sizeof(WCHAR);
794 RtlAppendUnicodeStringToString(&NewName, &TargetFileObject->FileName);
795 }
796
797 /* Explode our paths to get path & filename */
798 vfatSplitPathName(&FCB->PathNameU, &SourcePath, &SourceFile);
799 DPRINT("Old dir: %wZ, Old file: %wZ\n", &SourcePath, &SourceFile);
800 vfatSplitPathName(&NewName, &NewPath, &NewFile);
801 DPRINT("New dir: %wZ, New file: %wZ\n", &NewPath, &NewFile);
802
803 if (vfatFCBIsDirectory(FCB) && !IsListEmpty(&FCB->ParentListHead))
804 {
805 if (IsThereAChildOpened(FCB))
806 {
807 Status = STATUS_ACCESS_DENIED;
808 ASSERT(OldReferences == FCB->parentFcb->RefCount);
809 goto Cleanup;
810 }
811 }
812
813 /* Are we working in place? */
814 if (FsRtlAreNamesEqual(&SourcePath, &NewPath, TRUE, NULL))
815 {
816 if (FsRtlAreNamesEqual(&SourceFile, &NewFile, FALSE, NULL))
817 {
818 Status = STATUS_SUCCESS;
819 ASSERT(OldReferences == FCB->parentFcb->RefCount);
820 goto Cleanup;
821 }
822
823 if (FsRtlAreNamesEqual(&SourceFile, &NewFile, TRUE, NULL))
824 {
825 FsRtlNotifyFullReportChange(DeviceExt->NotifySync,
826 &(DeviceExt->NotifyList),
827 (PSTRING)&FCB->PathNameU,
828 FCB->PathNameU.Length - FCB->LongNameU.Length,
829 NULL,
830 NULL,
831 (vfatFCBIsDirectory(FCB) ?
832 FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME),
833 FILE_ACTION_RENAMED_OLD_NAME,
834 NULL);
835 Status = vfatRenameEntry(DeviceExt, FCB, &NewFile, TRUE);
836 if (NT_SUCCESS(Status))
837 {
838 FsRtlNotifyFullReportChange(DeviceExt->NotifySync,
839 &(DeviceExt->NotifyList),
840 (PSTRING)&FCB->PathNameU,
841 FCB->PathNameU.Length - FCB->LongNameU.Length,
842 NULL,
843 NULL,
844 (vfatFCBIsDirectory(FCB) ?
845 FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME),
846 FILE_ACTION_RENAMED_NEW_NAME,
847 NULL);
848 }
849 }
850 else
851 {
852 /* Try to find target */
853 ParentFCB = FCB->parentFcb;
854 vfatGrabFCB(DeviceExt, ParentFCB);
855 Status = vfatPrepareTargetForRename(DeviceExt,
856 &ParentFCB,
857 &NewFile,
858 RenameInfo->ReplaceIfExists,
859 &NewPath,
860 &DeletedTarget);
861 if (!NT_SUCCESS(Status))
862 {
863 ASSERT(OldReferences == FCB->parentFcb->RefCount - 1);
864 ASSERT(OldReferences == ParentFCB->RefCount - 1);
865 goto Cleanup;
866 }
867
868 FsRtlNotifyFullReportChange(DeviceExt->NotifySync,
869 &(DeviceExt->NotifyList),
870 (PSTRING)&FCB->PathNameU,
871 FCB->PathNameU.Length - FCB->LongNameU.Length,
872 NULL,
873 NULL,
874 (vfatFCBIsDirectory(FCB) ?
875 FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME),
876 (DeletedTarget ? FILE_ACTION_REMOVED : FILE_ACTION_RENAMED_OLD_NAME),
877 NULL);
878 Status = vfatRenameEntry(DeviceExt, FCB, &NewFile, FALSE);
879 if (NT_SUCCESS(Status))
880 {
881 if (DeletedTarget)
882 {
883 FsRtlNotifyFullReportChange(DeviceExt->NotifySync,
884 &(DeviceExt->NotifyList),
885 (PSTRING)&FCB->PathNameU,
886 FCB->PathNameU.Length - FCB->LongNameU.Length,
887 NULL,
888 NULL,
889 FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE
890 | FILE_NOTIFY_CHANGE_LAST_ACCESS | FILE_NOTIFY_CHANGE_CREATION | FILE_NOTIFY_CHANGE_EA,
891 FILE_ACTION_MODIFIED,
892 NULL);
893 }
894 else
895 {
896 FsRtlNotifyFullReportChange(DeviceExt->NotifySync,
897 &(DeviceExt->NotifyList),
898 (PSTRING)&FCB->PathNameU,
899 FCB->PathNameU.Length - FCB->LongNameU.Length,
900 NULL,
901 NULL,
902 (vfatFCBIsDirectory(FCB) ?
903 FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME),
904 FILE_ACTION_RENAMED_NEW_NAME,
905 NULL);
906 }
907 }
908 }
909
910 ASSERT(OldReferences == FCB->parentFcb->RefCount - 1); // extra grab
911 ASSERT(OldReferences == ParentFCB->RefCount - 1); // extra grab
912 }
913 else
914 {
915
916 /* Try to find target */
917 ParentFCB = NULL;
918 OldParent = FCB->parentFcb;
919 #ifdef NASSERTS_RENAME
920 UNREFERENCED_PARAMETER(OldParent);
921 #endif
922 Status = vfatPrepareTargetForRename(DeviceExt,
923 &ParentFCB,
924 &NewName,
925 RenameInfo->ReplaceIfExists,
926 &NewPath,
927 &DeletedTarget);
928 if (!NT_SUCCESS(Status))
929 {
930 ASSERT(OldReferences == FCB->parentFcb->RefCount);
931 goto Cleanup;
932 }
933
934 NewReferences = ParentFCB->RefCount;
935 #ifdef NASSERTS_RENAME
936 UNREFERENCED_PARAMETER(NewReferences);
937 #endif
938
939 FsRtlNotifyFullReportChange(DeviceExt->NotifySync,
940 &(DeviceExt->NotifyList),
941 (PSTRING)&FCB->PathNameU,
942 FCB->PathNameU.Length - FCB->LongNameU.Length,
943 NULL,
944 NULL,
945 (vfatFCBIsDirectory(FCB) ?
946 FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME),
947 FILE_ACTION_REMOVED,
948 NULL);
949 Status = VfatMoveEntry(DeviceExt, FCB, &NewFile, ParentFCB);
950 if (NT_SUCCESS(Status))
951 {
952 if (DeletedTarget)
953 {
954 FsRtlNotifyFullReportChange(DeviceExt->NotifySync,
955 &(DeviceExt->NotifyList),
956 (PSTRING)&FCB->PathNameU,
957 FCB->PathNameU.Length - FCB->LongNameU.Length,
958 NULL,
959 NULL,
960 FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE
961 | FILE_NOTIFY_CHANGE_LAST_ACCESS | FILE_NOTIFY_CHANGE_CREATION | FILE_NOTIFY_CHANGE_EA,
962 FILE_ACTION_MODIFIED,
963 NULL);
964 }
965 else
966 {
967 FsRtlNotifyFullReportChange(DeviceExt->NotifySync,
968 &(DeviceExt->NotifyList),
969 (PSTRING)&FCB->PathNameU,
970 FCB->PathNameU.Length - FCB->LongNameU.Length,
971 NULL,
972 NULL,
973 (vfatFCBIsDirectory(FCB) ?
974 FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME),
975 FILE_ACTION_ADDED,
976 NULL);
977 }
978 }
979 }
980
981 if (NT_SUCCESS(Status) && vfatFCBIsDirectory(FCB))
982 {
983 VfatRenameChildFCB(DeviceExt, FCB);
984 }
985
986 ASSERT(OldReferences == OldParent->RefCount + 1); // removed file
987 ASSERT(NewReferences == ParentFCB->RefCount - 1); // new file
988 Cleanup:
989 if (ParentFCB != NULL) vfatReleaseFCB(DeviceExt, ParentFCB);
990 if (NewName.Buffer != NULL) ExFreePoolWithTag(NewName.Buffer, TAG_VFAT);
991 if (RenameInfo->RootDirectory != NULL) ObDereferenceObject(RootFileObject);
992
993 return Status;
994 #ifdef NASSERTS_RENAME
995 #pragma pop_macro("ASSERT")
996 #endif
997 }
998
999 /*
1000 * FUNCTION: Retrieve the file name information
1001 */
1002 static
1003 NTSTATUS
1004 VfatGetNameInformation(
1005 PFILE_OBJECT FileObject,
1006 PVFATFCB FCB,
1007 PDEVICE_EXTENSION DeviceExt,
1008 PFILE_NAME_INFORMATION NameInfo,
1009 PULONG BufferLength)
1010 {
1011 ULONG BytesToCopy;
1012
1013 UNREFERENCED_PARAMETER(FileObject);
1014 UNREFERENCED_PARAMETER(DeviceExt);
1015
1016 ASSERT(NameInfo != NULL);
1017 ASSERT(FCB != NULL);
1018
1019 /* If buffer can't hold at least the file name length, bail out */
1020 if (*BufferLength < (ULONG)FIELD_OFFSET(FILE_NAME_INFORMATION, FileName[0]))
1021 return STATUS_BUFFER_OVERFLOW;
1022
1023 /* Save file name length, and as much file len, as buffer length allows */
1024 NameInfo->FileNameLength = FCB->PathNameU.Length;
1025
1026 /* Calculate amount of bytes to copy not to overflow the buffer */
1027 BytesToCopy = min(FCB->PathNameU.Length,
1028 *BufferLength - FIELD_OFFSET(FILE_NAME_INFORMATION, FileName[0]));
1029
1030 /* Fill in the bytes */
1031 RtlCopyMemory(NameInfo->FileName, FCB->PathNameU.Buffer, BytesToCopy);
1032
1033 /* Check if we could write more but are not able to */
1034 if (*BufferLength < FCB->PathNameU.Length + (ULONG)FIELD_OFFSET(FILE_NAME_INFORMATION, FileName[0]))
1035 {
1036 /* Return number of bytes written */
1037 *BufferLength -= FIELD_OFFSET(FILE_NAME_INFORMATION, FileName[0]) + BytesToCopy;
1038 return STATUS_BUFFER_OVERFLOW;
1039 }
1040
1041 /* We filled up as many bytes, as needed */
1042 *BufferLength -= (FIELD_OFFSET(FILE_NAME_INFORMATION, FileName[0]) + FCB->PathNameU.Length);
1043
1044 return STATUS_SUCCESS;
1045 }
1046
1047 static
1048 NTSTATUS
1049 VfatGetInternalInformation(
1050 PVFATFCB Fcb,
1051 PDEVICE_EXTENSION DeviceExt,
1052 PFILE_INTERNAL_INFORMATION InternalInfo,
1053 PULONG BufferLength)
1054 {
1055 ASSERT(InternalInfo);
1056 ASSERT(Fcb);
1057
1058 if (*BufferLength < sizeof(FILE_INTERNAL_INFORMATION))
1059 return STATUS_BUFFER_OVERFLOW;
1060
1061 InternalInfo->IndexNumber.QuadPart = (LONGLONG)vfatDirEntryGetFirstCluster(DeviceExt, &Fcb->entry) * DeviceExt->FatInfo.BytesPerCluster;
1062
1063 *BufferLength -= sizeof(FILE_INTERNAL_INFORMATION);
1064 return STATUS_SUCCESS;
1065 }
1066
1067
1068 /*
1069 * FUNCTION: Retrieve the file network open information
1070 */
1071 static
1072 NTSTATUS
1073 VfatGetNetworkOpenInformation(
1074 PVFATFCB Fcb,
1075 PDEVICE_EXTENSION DeviceExt,
1076 PFILE_NETWORK_OPEN_INFORMATION NetworkInfo,
1077 PULONG BufferLength)
1078 {
1079 ASSERT(NetworkInfo);
1080 ASSERT(Fcb);
1081
1082 if (*BufferLength < sizeof(FILE_NETWORK_OPEN_INFORMATION))
1083 return(STATUS_BUFFER_OVERFLOW);
1084
1085 if (vfatVolumeIsFatX(DeviceExt))
1086 {
1087 FsdDosDateTimeToSystemTime(DeviceExt,
1088 Fcb->entry.FatX.CreationDate,
1089 Fcb->entry.FatX.CreationTime,
1090 &NetworkInfo->CreationTime);
1091 FsdDosDateTimeToSystemTime(DeviceExt,
1092 Fcb->entry.FatX.AccessDate,
1093 Fcb->entry.FatX.AccessTime,
1094 &NetworkInfo->LastAccessTime);
1095 FsdDosDateTimeToSystemTime(DeviceExt,
1096 Fcb->entry.FatX.UpdateDate,
1097 Fcb->entry.FatX.UpdateTime,
1098 &NetworkInfo->LastWriteTime);
1099 NetworkInfo->ChangeTime.QuadPart = NetworkInfo->LastWriteTime.QuadPart;
1100 }
1101 else
1102 {
1103 FsdDosDateTimeToSystemTime(DeviceExt,
1104 Fcb->entry.Fat.CreationDate,
1105 Fcb->entry.Fat.CreationTime,
1106 &NetworkInfo->CreationTime);
1107 FsdDosDateTimeToSystemTime(DeviceExt,
1108 Fcb->entry.Fat.AccessDate,
1109 0,
1110 &NetworkInfo->LastAccessTime);
1111 FsdDosDateTimeToSystemTime(DeviceExt,
1112 Fcb->entry.Fat.UpdateDate,
1113 Fcb->entry.Fat.UpdateTime,
1114 &NetworkInfo->LastWriteTime);
1115 NetworkInfo->ChangeTime.QuadPart = NetworkInfo->LastWriteTime.QuadPart;
1116 }
1117
1118 if (vfatFCBIsDirectory(Fcb))
1119 {
1120 NetworkInfo->EndOfFile.QuadPart = 0L;
1121 NetworkInfo->AllocationSize.QuadPart = 0L;
1122 }
1123 else
1124 {
1125 NetworkInfo->AllocationSize = Fcb->RFCB.AllocationSize;
1126 NetworkInfo->EndOfFile = Fcb->RFCB.FileSize;
1127 }
1128
1129 NetworkInfo->FileAttributes = *Fcb->Attributes & 0x3f;
1130 /* Synthesize FILE_ATTRIBUTE_NORMAL */
1131 if (0 == (NetworkInfo->FileAttributes & (FILE_ATTRIBUTE_DIRECTORY |
1132 FILE_ATTRIBUTE_ARCHIVE |
1133 FILE_ATTRIBUTE_SYSTEM |
1134 FILE_ATTRIBUTE_HIDDEN |
1135 FILE_ATTRIBUTE_READONLY)))
1136 {
1137 DPRINT("Synthesizing FILE_ATTRIBUTE_NORMAL\n");
1138 NetworkInfo->FileAttributes |= FILE_ATTRIBUTE_NORMAL;
1139 }
1140
1141 *BufferLength -= sizeof(FILE_NETWORK_OPEN_INFORMATION);
1142 return STATUS_SUCCESS;
1143 }
1144
1145
1146 static
1147 NTSTATUS
1148 VfatGetEaInformation(
1149 PFILE_OBJECT FileObject,
1150 PVFATFCB Fcb,
1151 PDEVICE_EXTENSION DeviceExt,
1152 PFILE_EA_INFORMATION Info,
1153 PULONG BufferLength)
1154 {
1155 UNREFERENCED_PARAMETER(FileObject);
1156 UNREFERENCED_PARAMETER(Fcb);
1157
1158 /* FIXME - use SEH to access the buffer! */
1159 Info->EaSize = 0;
1160 *BufferLength -= sizeof(*Info);
1161 if (DeviceExt->FatInfo.FatType == FAT12 ||
1162 DeviceExt->FatInfo.FatType == FAT16)
1163 {
1164 /* FIXME */
1165 DPRINT1("VFAT: FileEaInformation not implemented!\n");
1166 }
1167 return STATUS_SUCCESS;
1168 }
1169
1170
1171 /*
1172 * FUNCTION: Retrieve the all file information
1173 */
1174 static
1175 NTSTATUS
1176 VfatGetAllInformation(
1177 PFILE_OBJECT FileObject,
1178 PVFATFCB Fcb,
1179 PDEVICE_EXTENSION DeviceExt,
1180 PFILE_ALL_INFORMATION Info,
1181 PULONG BufferLength)
1182 {
1183 NTSTATUS Status;
1184
1185 ASSERT(Info);
1186 ASSERT(Fcb);
1187
1188 if (*BufferLength < FIELD_OFFSET(FILE_ALL_INFORMATION, NameInformation.FileName))
1189 return STATUS_BUFFER_OVERFLOW;
1190
1191 *BufferLength -= (sizeof(FILE_ACCESS_INFORMATION) + sizeof(FILE_MODE_INFORMATION) + sizeof(FILE_ALIGNMENT_INFORMATION));
1192
1193 /* Basic Information */
1194 Status = VfatGetBasicInformation(FileObject, Fcb, DeviceExt, &Info->BasicInformation, BufferLength);
1195 if (!NT_SUCCESS(Status)) return Status;
1196 /* Standard Information */
1197 Status = VfatGetStandardInformation(Fcb, &Info->StandardInformation, BufferLength);
1198 if (!NT_SUCCESS(Status)) return Status;
1199 /* Internal Information */
1200 Status = VfatGetInternalInformation(Fcb, DeviceExt, &Info->InternalInformation, BufferLength);
1201 if (!NT_SUCCESS(Status)) return Status;
1202 /* EA Information */
1203 Status = VfatGetEaInformation(FileObject, Fcb, DeviceExt, &Info->EaInformation, BufferLength);
1204 if (!NT_SUCCESS(Status)) return Status;
1205 /* Position Information */
1206 Status = VfatGetPositionInformation(FileObject, Fcb, DeviceExt, &Info->PositionInformation, BufferLength);
1207 if (!NT_SUCCESS(Status)) return Status;
1208 /* Name Information */
1209 Status = VfatGetNameInformation(FileObject, Fcb, DeviceExt, &Info->NameInformation, BufferLength);
1210
1211 return Status;
1212 }
1213
1214 static
1215 VOID
1216 UpdateFileSize(
1217 PFILE_OBJECT FileObject,
1218 PVFATFCB Fcb,
1219 ULONG Size,
1220 ULONG ClusterSize,
1221 BOOLEAN IsFatX)
1222 {
1223 if (Size > 0)
1224 {
1225 Fcb->RFCB.AllocationSize.QuadPart = ROUND_UP_64(Size, ClusterSize);
1226 }
1227 else
1228 {
1229 Fcb->RFCB.AllocationSize.QuadPart = (LONGLONG)0;
1230 }
1231 if (!vfatFCBIsDirectory(Fcb))
1232 {
1233 if (IsFatX)
1234 Fcb->entry.FatX.FileSize = Size;
1235 else
1236 Fcb->entry.Fat.FileSize = Size;
1237 }
1238 Fcb->RFCB.FileSize.QuadPart = Size;
1239 Fcb->RFCB.ValidDataLength.QuadPart = Size;
1240
1241 CcSetFileSizes(FileObject, (PCC_FILE_SIZES)&Fcb->RFCB.AllocationSize);
1242 }
1243
1244 NTSTATUS
1245 VfatSetAllocationSizeInformation(
1246 PFILE_OBJECT FileObject,
1247 PVFATFCB Fcb,
1248 PDEVICE_EXTENSION DeviceExt,
1249 PLARGE_INTEGER AllocationSize)
1250 {
1251 ULONG OldSize;
1252 ULONG Cluster, FirstCluster;
1253 NTSTATUS Status;
1254
1255 ULONG ClusterSize = DeviceExt->FatInfo.BytesPerCluster;
1256 ULONG NewSize = AllocationSize->u.LowPart;
1257 ULONG NCluster;
1258 BOOLEAN AllocSizeChanged = FALSE, IsFatX = vfatVolumeIsFatX(DeviceExt);
1259
1260 DPRINT("VfatSetAllocationSizeInformation(File <%wZ>, AllocationSize %d %u)\n",
1261 &Fcb->PathNameU, AllocationSize->HighPart, AllocationSize->LowPart);
1262
1263 if (IsFatX)
1264 OldSize = Fcb->entry.FatX.FileSize;
1265 else
1266 OldSize = Fcb->entry.Fat.FileSize;
1267
1268 if (AllocationSize->u.HighPart > 0)
1269 {
1270 return STATUS_INVALID_PARAMETER;
1271 }
1272
1273 if (OldSize == NewSize)
1274 {
1275 return STATUS_SUCCESS;
1276 }
1277
1278 FirstCluster = vfatDirEntryGetFirstCluster(DeviceExt, &Fcb->entry);
1279
1280 if (NewSize > Fcb->RFCB.AllocationSize.u.LowPart)
1281 {
1282 AllocSizeChanged = TRUE;
1283 if (FirstCluster == 0)
1284 {
1285 Fcb->LastCluster = Fcb->LastOffset = 0;
1286 Status = NextCluster(DeviceExt, FirstCluster, &FirstCluster, TRUE);
1287 if (!NT_SUCCESS(Status))
1288 {
1289 DPRINT1("NextCluster failed. Status = %x\n", Status);
1290 return Status;
1291 }
1292
1293 if (FirstCluster == 0xffffffff)
1294 {
1295 return STATUS_DISK_FULL;
1296 }
1297
1298 Status = OffsetToCluster(DeviceExt, FirstCluster,
1299 ROUND_DOWN(NewSize - 1, ClusterSize),
1300 &NCluster, TRUE);
1301 if (NCluster == 0xffffffff || !NT_SUCCESS(Status))
1302 {
1303 /* disk is full */
1304 NCluster = Cluster = FirstCluster;
1305 Status = STATUS_SUCCESS;
1306 while (NT_SUCCESS(Status) && Cluster != 0xffffffff && Cluster > 1)
1307 {
1308 Status = NextCluster(DeviceExt, FirstCluster, &NCluster, FALSE);
1309 WriteCluster(DeviceExt, Cluster, 0);
1310 Cluster = NCluster;
1311 }
1312 return STATUS_DISK_FULL;
1313 }
1314
1315 if (IsFatX)
1316 {
1317 Fcb->entry.FatX.FirstCluster = FirstCluster;
1318 }
1319 else
1320 {
1321 if (DeviceExt->FatInfo.FatType == FAT32)
1322 {
1323 Fcb->entry.Fat.FirstCluster = (unsigned short)(FirstCluster & 0x0000FFFF);
1324 Fcb->entry.Fat.FirstClusterHigh = FirstCluster >> 16;
1325 }
1326 else
1327 {
1328 ASSERT((FirstCluster >> 16) == 0);
1329 Fcb->entry.Fat.FirstCluster = (unsigned short)(FirstCluster & 0x0000FFFF);
1330 }
1331 }
1332 }
1333 else
1334 {
1335 if (Fcb->LastCluster > 0)
1336 {
1337 if (Fcb->RFCB.AllocationSize.u.LowPart - ClusterSize == Fcb->LastOffset)
1338 {
1339 Cluster = Fcb->LastCluster;
1340 Status = STATUS_SUCCESS;
1341 }
1342 else
1343 {
1344 Status = OffsetToCluster(DeviceExt, Fcb->LastCluster,
1345 Fcb->RFCB.AllocationSize.u.LowPart - ClusterSize - Fcb->LastOffset,
1346 &Cluster, FALSE);
1347 }
1348 }
1349 else
1350 {
1351 Status = OffsetToCluster(DeviceExt, FirstCluster,
1352 Fcb->RFCB.AllocationSize.u.LowPart - ClusterSize,
1353 &Cluster, FALSE);
1354 }
1355
1356 if (!NT_SUCCESS(Status))
1357 {
1358 return Status;
1359 }
1360
1361 Fcb->LastCluster = Cluster;
1362 Fcb->LastOffset = Fcb->RFCB.AllocationSize.u.LowPart - ClusterSize;
1363
1364 /* FIXME: Check status */
1365 /* Cluster points now to the last cluster within the chain */
1366 Status = OffsetToCluster(DeviceExt, Cluster,
1367 ROUND_DOWN(NewSize - 1, ClusterSize) - Fcb->LastOffset,
1368 &NCluster, TRUE);
1369 if (NCluster == 0xffffffff || !NT_SUCCESS(Status))
1370 {
1371 /* disk is full */
1372 NCluster = Cluster;
1373 Status = NextCluster(DeviceExt, FirstCluster, &NCluster, FALSE);
1374 WriteCluster(DeviceExt, Cluster, 0xffffffff);
1375 Cluster = NCluster;
1376 while (NT_SUCCESS(Status) && Cluster != 0xffffffff && Cluster > 1)
1377 {
1378 Status = NextCluster(DeviceExt, FirstCluster, &NCluster, FALSE);
1379 WriteCluster(DeviceExt, Cluster, 0);
1380 Cluster = NCluster;
1381 }
1382 return STATUS_DISK_FULL;
1383 }
1384 }
1385 UpdateFileSize(FileObject, Fcb, NewSize, ClusterSize, vfatVolumeIsFatX(DeviceExt));
1386 }
1387 else if (NewSize + ClusterSize <= Fcb->RFCB.AllocationSize.u.LowPart)
1388 {
1389 DPRINT("Check for the ability to set file size\n");
1390 if (!MmCanFileBeTruncated(FileObject->SectionObjectPointer,
1391 (PLARGE_INTEGER)AllocationSize))
1392 {
1393 DPRINT("Couldn't set file size!\n");
1394 return STATUS_USER_MAPPED_FILE;
1395 }
1396 DPRINT("Can set file size\n");
1397
1398 AllocSizeChanged = TRUE;
1399 /* FIXME: Use the cached cluster/offset better way. */
1400 Fcb->LastCluster = Fcb->LastOffset = 0;
1401 UpdateFileSize(FileObject, Fcb, NewSize, ClusterSize, vfatVolumeIsFatX(DeviceExt));
1402 if (NewSize > 0)
1403 {
1404 Status = OffsetToCluster(DeviceExt, FirstCluster,
1405 ROUND_DOWN(NewSize - 1, ClusterSize),
1406 &Cluster, FALSE);
1407
1408 NCluster = Cluster;
1409 Status = NextCluster(DeviceExt, FirstCluster, &NCluster, FALSE);
1410 WriteCluster(DeviceExt, Cluster, 0xffffffff);
1411 Cluster = NCluster;
1412 }
1413 else
1414 {
1415 if (IsFatX)
1416 {
1417 Fcb->entry.FatX.FirstCluster = 0;
1418 }
1419 else
1420 {
1421 if (DeviceExt->FatInfo.FatType == FAT32)
1422 {
1423 Fcb->entry.Fat.FirstCluster = 0;
1424 Fcb->entry.Fat.FirstClusterHigh = 0;
1425 }
1426 else
1427 {
1428 Fcb->entry.Fat.FirstCluster = 0;
1429 }
1430 }
1431
1432 NCluster = Cluster = FirstCluster;
1433 Status = STATUS_SUCCESS;
1434 }
1435
1436 while (NT_SUCCESS(Status) && 0xffffffff != Cluster && Cluster > 1)
1437 {
1438 Status = NextCluster(DeviceExt, FirstCluster, &NCluster, FALSE);
1439 WriteCluster(DeviceExt, Cluster, 0);
1440 Cluster = NCluster;
1441 }
1442 }
1443 else
1444 {
1445 UpdateFileSize(FileObject, Fcb, NewSize, ClusterSize, vfatVolumeIsFatX(DeviceExt));
1446 }
1447
1448 /* Update the on-disk directory entry */
1449 Fcb->Flags |= FCB_IS_DIRTY;
1450 if (AllocSizeChanged)
1451 {
1452 VfatUpdateEntry(Fcb, vfatVolumeIsFatX(DeviceExt));
1453 }
1454 return STATUS_SUCCESS;
1455 }
1456
1457 /*
1458 * FUNCTION: Retrieve the specified file information
1459 */
1460 NTSTATUS
1461 VfatQueryInformation(
1462 PVFAT_IRP_CONTEXT IrpContext)
1463 {
1464 FILE_INFORMATION_CLASS FileInformationClass;
1465 PVFATFCB FCB;
1466
1467 NTSTATUS Status = STATUS_SUCCESS;
1468 PVOID SystemBuffer;
1469 ULONG BufferLength;
1470
1471 /* PRECONDITION */
1472 ASSERT(IrpContext);
1473
1474 /* INITIALIZATION */
1475 FileInformationClass = IrpContext->Stack->Parameters.QueryFile.FileInformationClass;
1476 FCB = (PVFATFCB) IrpContext->FileObject->FsContext;
1477
1478 DPRINT("VfatQueryInformation is called for '%s'\n",
1479 FileInformationClass >= FileMaximumInformation - 1 ? "????" : FileInformationClassNames[FileInformationClass]);
1480
1481 if (FCB == NULL)
1482 {
1483 DPRINT1("IRP_MJ_QUERY_INFORMATION without FCB!\n");
1484 IrpContext->Irp->IoStatus.Information = 0;
1485 return STATUS_INVALID_PARAMETER;
1486 }
1487
1488 SystemBuffer = IrpContext->Irp->AssociatedIrp.SystemBuffer;
1489 BufferLength = IrpContext->Stack->Parameters.QueryFile.Length;
1490
1491 if (!BooleanFlagOn(FCB->Flags, FCB_IS_PAGE_FILE))
1492 {
1493 if (!ExAcquireResourceSharedLite(&FCB->MainResource,
1494 BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT)))
1495 {
1496 return VfatMarkIrpContextForQueue(IrpContext);
1497 }
1498 }
1499
1500 switch (FileInformationClass)
1501 {
1502 case FileStandardInformation:
1503 Status = VfatGetStandardInformation(FCB,
1504 SystemBuffer,
1505 &BufferLength);
1506 break;
1507
1508 case FilePositionInformation:
1509 Status = VfatGetPositionInformation(IrpContext->FileObject,
1510 FCB,
1511 IrpContext->DeviceExt,
1512 SystemBuffer,
1513 &BufferLength);
1514 break;
1515
1516 case FileBasicInformation:
1517 Status = VfatGetBasicInformation(IrpContext->FileObject,
1518 FCB,
1519 IrpContext->DeviceExt,
1520 SystemBuffer,
1521 &BufferLength);
1522 break;
1523
1524 case FileNameInformation:
1525 Status = VfatGetNameInformation(IrpContext->FileObject,
1526 FCB,
1527 IrpContext->DeviceExt,
1528 SystemBuffer,
1529 &BufferLength);
1530 break;
1531
1532 case FileInternalInformation:
1533 Status = VfatGetInternalInformation(FCB,
1534 IrpContext->DeviceExt,
1535 SystemBuffer,
1536 &BufferLength);
1537 break;
1538
1539 case FileNetworkOpenInformation:
1540 Status = VfatGetNetworkOpenInformation(FCB,
1541 IrpContext->DeviceExt,
1542 SystemBuffer,
1543 &BufferLength);
1544 break;
1545
1546 case FileAllInformation:
1547 Status = VfatGetAllInformation(IrpContext->FileObject,
1548 FCB,
1549 IrpContext->DeviceExt,
1550 SystemBuffer,
1551 &BufferLength);
1552 break;
1553
1554 case FileEaInformation:
1555 Status = VfatGetEaInformation(IrpContext->FileObject,
1556 FCB,
1557 IrpContext->DeviceExt,
1558 SystemBuffer,
1559 &BufferLength);
1560 break;
1561
1562 case FileAlternateNameInformation:
1563 Status = STATUS_NOT_IMPLEMENTED;
1564 break;
1565
1566 default:
1567 Status = STATUS_INVALID_PARAMETER;
1568 }
1569
1570 if (!BooleanFlagOn(FCB->Flags, FCB_IS_PAGE_FILE))
1571 {
1572 ExReleaseResourceLite(&FCB->MainResource);
1573 }
1574
1575 if (NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW)
1576 IrpContext->Irp->IoStatus.Information =
1577 IrpContext->Stack->Parameters.QueryFile.Length - BufferLength;
1578 else
1579 IrpContext->Irp->IoStatus.Information = 0;
1580
1581 return Status;
1582 }
1583
1584 /*
1585 * FUNCTION: Retrieve the specified file information
1586 */
1587 NTSTATUS
1588 VfatSetInformation(
1589 PVFAT_IRP_CONTEXT IrpContext)
1590 {
1591 FILE_INFORMATION_CLASS FileInformationClass;
1592 PVFATFCB FCB;
1593 NTSTATUS Status = STATUS_SUCCESS;
1594 PVOID SystemBuffer;
1595
1596 /* PRECONDITION */
1597 ASSERT(IrpContext);
1598
1599 DPRINT("VfatSetInformation(IrpContext %p)\n", IrpContext);
1600
1601 /* INITIALIZATION */
1602 FileInformationClass =
1603 IrpContext->Stack->Parameters.SetFile.FileInformationClass;
1604 FCB = (PVFATFCB) IrpContext->FileObject->FsContext;
1605 SystemBuffer = IrpContext->Irp->AssociatedIrp.SystemBuffer;
1606
1607 DPRINT("VfatSetInformation is called for '%s'\n",
1608 FileInformationClass >= FileMaximumInformation - 1 ? "????" : FileInformationClassNames[ FileInformationClass]);
1609
1610 DPRINT("FileInformationClass %d\n", FileInformationClass);
1611 DPRINT("SystemBuffer %p\n", SystemBuffer);
1612
1613 if (FCB == NULL)
1614 {
1615 DPRINT1("IRP_MJ_SET_INFORMATION without FCB!\n");
1616 IrpContext->Irp->IoStatus.Information = 0;
1617 return STATUS_INVALID_PARAMETER;
1618 }
1619
1620 /* Special: We should call MmCanFileBeTruncated here to determine if changing
1621 the file size would be allowed. If not, we bail with the right error.
1622 We must do this before acquiring the lock. */
1623 if (FileInformationClass == FileEndOfFileInformation)
1624 {
1625 DPRINT("Check for the ability to set file size\n");
1626 if (!MmCanFileBeTruncated(IrpContext->FileObject->SectionObjectPointer,
1627 (PLARGE_INTEGER)SystemBuffer))
1628 {
1629 DPRINT("Couldn't set file size!\n");
1630 IrpContext->Irp->IoStatus.Information = 0;
1631 return STATUS_USER_MAPPED_FILE;
1632 }
1633 DPRINT("Can set file size\n");
1634 }
1635
1636 if (FileInformationClass == FileRenameInformation)
1637 {
1638 if (!ExAcquireResourceExclusiveLite(&((PDEVICE_EXTENSION)IrpContext->DeviceObject->DeviceExtension)->DirResource,
1639 BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT)))
1640 {
1641 return VfatMarkIrpContextForQueue(IrpContext);
1642 }
1643 }
1644
1645 if (!BooleanFlagOn(FCB->Flags, FCB_IS_PAGE_FILE))
1646 {
1647 if (!ExAcquireResourceExclusiveLite(&FCB->MainResource,
1648 BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT)))
1649 {
1650 if (FileInformationClass == FileRenameInformation)
1651 {
1652 ExReleaseResourceLite(&((PDEVICE_EXTENSION)IrpContext->DeviceObject->DeviceExtension)->DirResource);
1653 }
1654
1655 return VfatMarkIrpContextForQueue(IrpContext);
1656 }
1657 }
1658
1659 switch (FileInformationClass)
1660 {
1661 case FilePositionInformation:
1662 Status = VfatSetPositionInformation(IrpContext->FileObject,
1663 SystemBuffer);
1664 break;
1665
1666 case FileDispositionInformation:
1667 Status = VfatSetDispositionInformation(IrpContext->FileObject,
1668 FCB,
1669 IrpContext->DeviceExt,
1670 SystemBuffer);
1671 break;
1672
1673 case FileAllocationInformation:
1674 case FileEndOfFileInformation:
1675 Status = VfatSetAllocationSizeInformation(IrpContext->FileObject,
1676 FCB,
1677 IrpContext->DeviceExt,
1678 (PLARGE_INTEGER)SystemBuffer);
1679 break;
1680
1681 case FileBasicInformation:
1682 Status = VfatSetBasicInformation(IrpContext->FileObject,
1683 FCB,
1684 IrpContext->DeviceExt,
1685 SystemBuffer);
1686 break;
1687
1688 case FileRenameInformation:
1689 Status = VfatSetRenameInformation(IrpContext->FileObject,
1690 FCB,
1691 IrpContext->DeviceExt,
1692 SystemBuffer,
1693 IrpContext->Stack->Parameters.SetFile.FileObject);
1694 break;
1695
1696 default:
1697 Status = STATUS_NOT_SUPPORTED;
1698 }
1699
1700 if (!BooleanFlagOn(FCB->Flags, FCB_IS_PAGE_FILE))
1701 {
1702 ExReleaseResourceLite(&FCB->MainResource);
1703 }
1704
1705 if (FileInformationClass == FileRenameInformation)
1706 {
1707 ExReleaseResourceLite(&((PDEVICE_EXTENSION)IrpContext->DeviceObject->DeviceExtension)->DirResource);
1708 }
1709
1710 IrpContext->Irp->IoStatus.Information = 0;
1711 return Status;
1712 }
1713
1714 /* EOF */