[FASTFAT]
[reactos.git] / reactos / drivers / filesystems / fastfat / create.c
1 /*
2 * ReactOS kernel
3 * Copyright (C) 1998, 1999, 2000, 2001 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 along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19 /*
20 * PROJECT: ReactOS kernel
21 * FILE: drivers/filesystems/fastfat/create.c
22 * PURPOSE: VFAT Filesystem
23 * PROGRAMMER: Jason Filby (jasonfilby@yahoo.com)
24 * Pierre Schweitzer (pierre@reactos.org)
25 */
26
27 /* INCLUDES *****************************************************************/
28
29 #include "vfat.h"
30
31 #define NDEBUG
32 #include <debug.h>
33
34 /* FUNCTIONS *****************************************************************/
35
36 VOID
37 vfat8Dot3ToString(
38 PFAT_DIR_ENTRY pEntry,
39 PUNICODE_STRING NameU)
40 {
41 OEM_STRING StringA;
42 USHORT Length;
43 CHAR cString[12];
44
45 RtlCopyMemory(cString, pEntry->ShortName, 11);
46 cString[11] = 0;
47 if (cString[0] == 0x05)
48 {
49 cString[0] = 0xe5;
50 }
51
52 StringA.Buffer = cString;
53 for (StringA.Length = 0;
54 StringA.Length < 8 && StringA.Buffer[StringA.Length] != ' ';
55 StringA.Length++);
56 StringA.MaximumLength = StringA.Length;
57
58 RtlOemStringToUnicodeString(NameU, &StringA, FALSE);
59
60 if (pEntry->lCase & VFAT_CASE_LOWER_BASE)
61 {
62 RtlDowncaseUnicodeString(NameU, NameU, FALSE);
63 }
64
65 if (cString[8] != ' ')
66 {
67 Length = NameU->Length;
68 NameU->Buffer += Length / sizeof(WCHAR);
69 if (!FAT_ENTRY_VOLUME(pEntry))
70 {
71 Length += sizeof(WCHAR);
72 NameU->Buffer[0] = L'.';
73 NameU->Buffer++;
74 }
75 NameU->Length = 0;
76 NameU->MaximumLength -= Length;
77
78 StringA.Buffer = &cString[8];
79 for (StringA.Length = 0;
80 StringA.Length < 3 && StringA.Buffer[StringA.Length] != ' ';
81 StringA.Length++);
82 StringA.MaximumLength = StringA.Length;
83 RtlOemStringToUnicodeString(NameU, &StringA, FALSE);
84 if (pEntry->lCase & VFAT_CASE_LOWER_EXT)
85 {
86 RtlDowncaseUnicodeString(NameU, NameU, FALSE);
87 }
88 NameU->Buffer -= Length / sizeof(WCHAR);
89 NameU->Length += Length;
90 NameU->MaximumLength += Length;
91 }
92
93 NameU->Buffer[NameU->Length / sizeof(WCHAR)] = 0;
94 DPRINT("'%wZ'\n", NameU);
95 }
96
97 /*
98 * FUNCTION: Read the volume label
99 */
100 NTSTATUS
101 ReadVolumeLabel(
102 PDEVICE_EXTENSION DeviceExt,
103 PVPB Vpb)
104 {
105 PVOID Context = NULL;
106 ULONG DirIndex = 0;
107 PDIR_ENTRY Entry;
108 PVFATFCB pFcb;
109 LARGE_INTEGER FileOffset;
110 UNICODE_STRING NameU;
111 ULONG SizeDirEntry;
112 ULONG EntriesPerPage;
113 OEM_STRING StringO;
114
115 NameU.Buffer = Vpb->VolumeLabel;
116 NameU.Length = 0;
117 NameU.MaximumLength = sizeof(Vpb->VolumeLabel);
118 *(Vpb->VolumeLabel) = 0;
119 Vpb->VolumeLabelLength = 0;
120
121 if (DeviceExt->Flags & VCB_IS_FATX)
122 {
123 SizeDirEntry = sizeof(FATX_DIR_ENTRY);
124 EntriesPerPage = FATX_ENTRIES_PER_PAGE;
125 }
126 else
127 {
128 SizeDirEntry = sizeof(FAT_DIR_ENTRY);
129 EntriesPerPage = FAT_ENTRIES_PER_PAGE;
130 }
131
132 ExAcquireResourceExclusiveLite(&DeviceExt->DirResource, TRUE);
133 pFcb = vfatOpenRootFCB(DeviceExt);
134 ExReleaseResourceLite(&DeviceExt->DirResource);
135
136 FileOffset.QuadPart = 0;
137 if (CcMapData(pFcb->FileObject, &FileOffset, SizeDirEntry, TRUE, &Context, (PVOID*)&Entry))
138 {
139 while (TRUE)
140 {
141 if (ENTRY_VOLUME(DeviceExt, Entry))
142 {
143 /* copy volume label */
144 if (DeviceExt->Flags & VCB_IS_FATX)
145 {
146 StringO.Buffer = (PCHAR)Entry->FatX.Filename;
147 StringO.MaximumLength = StringO.Length = Entry->FatX.FilenameLength;
148 RtlOemStringToUnicodeString(&NameU, &StringO, FALSE);
149 }
150 else
151 {
152 vfat8Dot3ToString(&Entry->Fat, &NameU);
153 }
154 Vpb->VolumeLabelLength = NameU.Length;
155 break;
156 }
157 if (ENTRY_END(DeviceExt, Entry))
158 {
159 break;
160 }
161 DirIndex++;
162 Entry = (PDIR_ENTRY)((ULONG_PTR)Entry + SizeDirEntry);
163 if ((DirIndex % EntriesPerPage) == 0)
164 {
165 CcUnpinData(Context);
166 FileOffset.u.LowPart += PAGE_SIZE;
167 if (!CcMapData(pFcb->FileObject, &FileOffset, SizeDirEntry, TRUE, &Context, (PVOID*)&Entry))
168 {
169 Context = NULL;
170 break;
171 }
172 }
173 }
174 if (Context)
175 {
176 CcUnpinData(Context);
177 }
178 }
179 ExAcquireResourceExclusiveLite(&DeviceExt->DirResource, TRUE);
180 vfatReleaseFCB(DeviceExt, pFcb);
181 ExReleaseResourceLite(&DeviceExt->DirResource);
182
183 return STATUS_SUCCESS;
184 }
185
186 /*
187 * FUNCTION: Find a file
188 */
189 NTSTATUS
190 FindFile(
191 PDEVICE_EXTENSION DeviceExt,
192 PVFATFCB Parent,
193 PUNICODE_STRING FileToFindU,
194 PVFAT_DIRENTRY_CONTEXT DirContext,
195 BOOLEAN First)
196 {
197 PWCHAR PathNameBuffer;
198 USHORT PathNameBufferLength;
199 NTSTATUS Status;
200 PVOID Context = NULL;
201 PVOID Page;
202 PVFATFCB rcFcb;
203 BOOLEAN Found;
204 UNICODE_STRING PathNameU;
205 UNICODE_STRING FileToFindUpcase;
206 BOOLEAN WildCard;
207
208 DPRINT("FindFile(Parent %p, FileToFind '%wZ', DirIndex: %u)\n",
209 Parent, FileToFindU, DirContext->DirIndex);
210 DPRINT("FindFile: Path %wZ\n",&Parent->PathNameU);
211
212 PathNameBufferLength = LONGNAME_MAX_LENGTH * sizeof(WCHAR);
213 PathNameBuffer = ExAllocatePoolWithTag(NonPagedPool, PathNameBufferLength + sizeof(WCHAR), TAG_VFAT);
214 if (!PathNameBuffer)
215 {
216 return STATUS_INSUFFICIENT_RESOURCES;
217 }
218
219 PathNameU.Buffer = PathNameBuffer;
220 PathNameU.Length = 0;
221 PathNameU.MaximumLength = PathNameBufferLength;
222
223 DirContext->LongNameU.Length = 0;
224 DirContext->ShortNameU.Length = 0;
225
226 WildCard = FsRtlDoesNameContainWildCards(FileToFindU);
227
228 if (WildCard == FALSE)
229 {
230 /* if there is no '*?' in the search name, than look first for an existing fcb */
231 RtlCopyUnicodeString(&PathNameU, &Parent->PathNameU);
232 if (!vfatFCBIsRoot(Parent))
233 {
234 PathNameU.Buffer[PathNameU.Length / sizeof(WCHAR)] = L'\\';
235 PathNameU.Length += sizeof(WCHAR);
236 }
237 RtlAppendUnicodeStringToString(&PathNameU, FileToFindU);
238 PathNameU.Buffer[PathNameU.Length / sizeof(WCHAR)] = 0;
239 rcFcb = vfatGrabFCBFromTable(DeviceExt, &PathNameU);
240 if (rcFcb)
241 {
242 ULONG startIndex = rcFcb->startIndex;
243 if ((rcFcb->Flags & FCB_IS_FATX_ENTRY) && !vfatFCBIsRoot(Parent))
244 {
245 startIndex += 2;
246 }
247 if(startIndex >= DirContext->DirIndex)
248 {
249 RtlCopyUnicodeString(&DirContext->LongNameU, &rcFcb->LongNameU);
250 RtlCopyUnicodeString(&DirContext->ShortNameU, &rcFcb->ShortNameU);
251 RtlCopyMemory(&DirContext->DirEntry, &rcFcb->entry, sizeof(DIR_ENTRY));
252 DirContext->StartIndex = rcFcb->startIndex;
253 DirContext->DirIndex = rcFcb->dirIndex;
254 DPRINT("FindFile: new Name %wZ, DirIndex %u (%u)\n",
255 &DirContext->LongNameU, DirContext->DirIndex, DirContext->StartIndex);
256 Status = STATUS_SUCCESS;
257 }
258 else
259 {
260 DPRINT("FCB not found for %wZ\n", &PathNameU);
261 Status = STATUS_UNSUCCESSFUL;
262 }
263 vfatReleaseFCB(DeviceExt, rcFcb);
264 ExFreePool(PathNameBuffer);
265 return Status;
266 }
267 }
268
269 /* FsRtlIsNameInExpression need the searched string to be upcase,
270 * even if IgnoreCase is specified */
271 Status = RtlUpcaseUnicodeString(&FileToFindUpcase, FileToFindU, TRUE);
272 if (!NT_SUCCESS(Status))
273 {
274 ExFreePool(PathNameBuffer);
275 return Status;
276 }
277
278 while (TRUE)
279 {
280 Status = DeviceExt->GetNextDirEntry(&Context, &Page, Parent, DirContext, First);
281 First = FALSE;
282 if (Status == STATUS_NO_MORE_ENTRIES)
283 {
284 break;
285 }
286 if (ENTRY_VOLUME(DeviceExt, &DirContext->DirEntry))
287 {
288 DirContext->DirIndex++;
289 continue;
290 }
291 if (WildCard)
292 {
293 Found = FsRtlIsNameInExpression(&FileToFindUpcase, &DirContext->LongNameU, TRUE, NULL) ||
294 FsRtlIsNameInExpression(&FileToFindUpcase, &DirContext->ShortNameU, TRUE, NULL);
295 }
296 else
297 {
298 Found = FsRtlAreNamesEqual(&DirContext->LongNameU, FileToFindU, TRUE, NULL) ||
299 FsRtlAreNamesEqual(&DirContext->ShortNameU, FileToFindU, TRUE, NULL);
300 }
301
302 if (Found)
303 {
304 if (WildCard)
305 {
306 RtlCopyUnicodeString(&PathNameU, &Parent->PathNameU);
307 if (!vfatFCBIsRoot(Parent))
308 {
309 PathNameU.Buffer[PathNameU.Length / sizeof(WCHAR)] = L'\\';
310 PathNameU.Length += sizeof(WCHAR);
311 }
312 RtlAppendUnicodeStringToString(&PathNameU, &DirContext->LongNameU);
313 PathNameU.Buffer[PathNameU.Length / sizeof(WCHAR)] = 0;
314 rcFcb = vfatGrabFCBFromTable(DeviceExt, &PathNameU);
315 if (rcFcb != NULL)
316 {
317 RtlCopyMemory(&DirContext->DirEntry, &rcFcb->entry, sizeof(DIR_ENTRY));
318 vfatReleaseFCB(DeviceExt, rcFcb);
319 }
320 }
321 DPRINT("%u\n", DirContext->LongNameU.Length);
322 DPRINT("FindFile: new Name %wZ, DirIndex %u\n",
323 &DirContext->LongNameU, DirContext->DirIndex);
324
325 if (Context)
326 {
327 CcUnpinData(Context);
328 }
329 RtlFreeUnicodeString(&FileToFindUpcase);
330 ExFreePool(PathNameBuffer);
331 return STATUS_SUCCESS;
332 }
333 DirContext->DirIndex++;
334 }
335
336 if (Context)
337 {
338 CcUnpinData(Context);
339 }
340
341 RtlFreeUnicodeString(&FileToFindUpcase);
342 ExFreePool(PathNameBuffer);
343 return Status;
344 }
345
346 /*
347 * FUNCTION: Opens a file
348 */
349 static
350 NTSTATUS
351 VfatOpenFile(
352 PDEVICE_EXTENSION DeviceExt,
353 PUNICODE_STRING PathNameU,
354 PFILE_OBJECT FileObject,
355 ULONG RequestedDisposition,
356 PVFATFCB *ParentFcb)
357 {
358 PVFATFCB Fcb;
359 NTSTATUS Status;
360
361 DPRINT("VfatOpenFile(%p, '%wZ', %p, %p)\n", DeviceExt, PathNameU, FileObject, ParentFcb);
362
363 if (FileObject->RelatedFileObject)
364 {
365 DPRINT("'%wZ'\n", &FileObject->RelatedFileObject->FileName);
366
367 *ParentFcb = FileObject->RelatedFileObject->FsContext;
368 }
369 else
370 {
371 *ParentFcb = NULL;
372 }
373
374 if (!DeviceExt->FatInfo.FixedMedia)
375 {
376 Status = VfatBlockDeviceIoControl(DeviceExt->StorageDevice,
377 IOCTL_DISK_CHECK_VERIFY,
378 NULL,
379 0,
380 NULL,
381 0,
382 FALSE);
383 if (!NT_SUCCESS(Status))
384 {
385 DPRINT("Status %lx\n", Status);
386 *ParentFcb = NULL;
387 return Status;
388 }
389 }
390
391 if (*ParentFcb)
392 {
393 vfatGrabFCB(DeviceExt, *ParentFcb);
394 }
395
396 /* try first to find an existing FCB in memory */
397 DPRINT("Checking for existing FCB in memory\n");
398
399 Status = vfatGetFCBForFile(DeviceExt, ParentFcb, &Fcb, PathNameU);
400 if (!NT_SUCCESS(Status))
401 {
402 DPRINT ("Could not make a new FCB, status: %x\n", Status);
403 return Status;
404 }
405
406 if (Fcb->Flags & FCB_DELETE_PENDING)
407 {
408 vfatReleaseFCB(DeviceExt, Fcb);
409 return STATUS_DELETE_PENDING;
410 }
411
412 /* Fail, if we try to overwrite a read-only file */
413 if ((*Fcb->Attributes & FILE_ATTRIBUTE_READONLY) &&
414 (RequestedDisposition == FILE_OVERWRITE))
415 {
416 vfatReleaseFCB(DeviceExt, Fcb);
417 return STATUS_ACCESS_DENIED;
418 }
419
420 DPRINT("Attaching FCB to fileObject\n");
421 Status = vfatAttachFCBToFileObject(DeviceExt, Fcb, FileObject);
422 if (!NT_SUCCESS(Status))
423 {
424 vfatReleaseFCB(DeviceExt, Fcb);
425 }
426 return Status;
427 }
428
429 /*
430 * FUNCTION: Create or open a file
431 */
432 static NTSTATUS
433 VfatCreateFile(
434 PDEVICE_OBJECT DeviceObject,
435 PIRP Irp)
436 {
437 PIO_STACK_LOCATION Stack;
438 PFILE_OBJECT FileObject;
439 NTSTATUS Status = STATUS_SUCCESS;
440 PDEVICE_EXTENSION DeviceExt;
441 ULONG RequestedDisposition, RequestedOptions;
442 PVFATFCB pFcb = NULL;
443 PVFATFCB ParentFcb = NULL;
444 PWCHAR c, last;
445 BOOLEAN PagingFileCreate;
446 BOOLEAN Dots;
447 BOOLEAN OpenTargetDir;
448 UNICODE_STRING FileNameU;
449 UNICODE_STRING PathNameU;
450 ULONG Attributes;
451
452 /* Unpack the various parameters. */
453 Stack = IoGetCurrentIrpStackLocation(Irp);
454 RequestedDisposition = ((Stack->Parameters.Create.Options >> 24) & 0xff);
455 RequestedOptions = Stack->Parameters.Create.Options & FILE_VALID_OPTION_FLAGS;
456 PagingFileCreate = (Stack->Flags & SL_OPEN_PAGING_FILE) ? TRUE : FALSE;
457 OpenTargetDir = (Stack->Flags & SL_OPEN_TARGET_DIRECTORY) ? TRUE : FALSE;
458
459 FileObject = Stack->FileObject;
460 DeviceExt = DeviceObject->DeviceExtension;
461
462 /* Check their validity. */
463 if (RequestedOptions & FILE_DIRECTORY_FILE &&
464 RequestedDisposition == FILE_SUPERSEDE)
465 {
466 return STATUS_INVALID_PARAMETER;
467 }
468
469 if (RequestedOptions & FILE_DIRECTORY_FILE &&
470 RequestedOptions & FILE_NON_DIRECTORY_FILE)
471 {
472 return STATUS_INVALID_PARAMETER;
473 }
474
475 /* Deny create if the volume is locked */
476 if (DeviceExt->Flags & VCB_VOLUME_LOCKED)
477 {
478 return STATUS_ACCESS_DENIED;
479 }
480
481 /* This a open operation for the volume itself */
482 if (FileObject->FileName.Length == 0 &&
483 (FileObject->RelatedFileObject == NULL || FileObject->RelatedFileObject->FsContext2 != NULL))
484 {
485 DPRINT("Volume opening\n");
486
487 if (RequestedDisposition != FILE_OPEN &&
488 RequestedDisposition != FILE_OPEN_IF)
489 {
490 return STATUS_ACCESS_DENIED;
491 }
492 #if 0
493 /* In spite of what is shown in WDK, it seems that Windows FAT driver doesn't perform that test */
494 if (RequestedOptions & FILE_DIRECTORY_FILE)
495 {
496 return STATUS_NOT_A_DIRECTORY;
497 }
498 #endif
499
500 if (OpenTargetDir)
501 {
502 return STATUS_INVALID_PARAMETER;
503 }
504
505 pFcb = DeviceExt->VolumeFcb;
506
507 if (pFcb->OpenHandleCount == 0)
508 {
509 IoSetShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
510 Stack->Parameters.Create.ShareAccess,
511 FileObject,
512 &pFcb->FCBShareAccess);
513 }
514 else
515 {
516 Status = IoCheckShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
517 Stack->Parameters.Create.ShareAccess,
518 FileObject,
519 &pFcb->FCBShareAccess,
520 FALSE);
521 if (!NT_SUCCESS(Status))
522 {
523 return Status;
524 }
525 }
526
527 vfatAttachFCBToFileObject(DeviceExt, pFcb, FileObject);
528 DeviceExt->OpenHandleCount++;
529
530 Irp->IoStatus.Information = FILE_OPENED;
531 return STATUS_SUCCESS;
532 }
533
534 /* Check for illegal characters and illegale dot sequences in the file name */
535 PathNameU = FileObject->FileName;
536 c = PathNameU.Buffer + PathNameU.Length / sizeof(WCHAR);
537 last = c - 1;
538 Dots = TRUE;
539 while (c-- > PathNameU.Buffer)
540 {
541 if (*c == L'\\' || c == PathNameU.Buffer)
542 {
543 if (Dots && last > c)
544 {
545 return STATUS_OBJECT_NAME_INVALID;
546 }
547 last = c - 1;
548 Dots = TRUE;
549 }
550 else if (*c != L'.')
551 {
552 Dots = FALSE;
553 }
554
555 if (*c != '\\' && vfatIsLongIllegal(*c))
556 {
557 return STATUS_OBJECT_NAME_INVALID;
558 }
559 }
560
561 /* Check if we try to open target directory of root dir */
562 if (OpenTargetDir && FileObject->RelatedFileObject == NULL && PathNameU.Length == sizeof(WCHAR) &&
563 PathNameU.Buffer[0] == L'\\')
564 {
565 return STATUS_INVALID_PARAMETER;
566 }
567
568 if (FileObject->RelatedFileObject && PathNameU.Length >= sizeof(WCHAR) && PathNameU.Buffer[0] == L'\\')
569 {
570 return STATUS_OBJECT_NAME_INVALID;
571 }
572
573 if (PathNameU.Length > sizeof(WCHAR) && PathNameU.Buffer[PathNameU.Length/sizeof(WCHAR)-1] == L'\\')
574 {
575 PathNameU.Length -= sizeof(WCHAR);
576 }
577
578 /* Try opening the file. */
579 if (!OpenTargetDir)
580 {
581 Status = VfatOpenFile(DeviceExt, &PathNameU, FileObject, RequestedDisposition, &ParentFcb);
582 }
583 else
584 {
585 PVFATFCB TargetFcb;
586 LONG idx, FileNameLen;
587
588 ParentFcb = (FileObject->RelatedFileObject != NULL) ? FileObject->RelatedFileObject->FsContext : NULL;
589 if (ParentFcb)
590 {
591 vfatGrabFCB(DeviceExt, ParentFcb);
592 }
593 Status = vfatGetFCBForFile(DeviceExt, &ParentFcb, &TargetFcb, &PathNameU);
594
595 if (NT_SUCCESS(Status))
596 {
597 vfatReleaseFCB(DeviceExt, TargetFcb);
598 Irp->IoStatus.Information = FILE_EXISTS;
599 }
600 else
601 {
602 Irp->IoStatus.Information = FILE_DOES_NOT_EXIST;
603 }
604
605 idx = FileObject->FileName.Length / sizeof(WCHAR) - 1;
606
607 /* Skip trailing \ - if any */
608 if (PathNameU.Buffer[idx] == L'\\')
609 {
610 --idx;
611 PathNameU.Length -= sizeof(WCHAR);
612 }
613
614 /* Get file name */
615 while (idx >= 0 && PathNameU.Buffer[idx] != L'\\')
616 {
617 --idx;
618 }
619
620 if (idx > 0 || PathNameU.Buffer[0] == L'\\')
621 {
622 /* We don't want to include / in the name */
623 FileNameLen = PathNameU.Length - ((idx + 1) * sizeof(WCHAR));
624
625 /* Update FO just to keep file name */
626 /* Skip first slash */
627 ++idx;
628 FileObject->FileName.Length = FileNameLen;
629 RtlMoveMemory(&PathNameU.Buffer[0], &PathNameU.Buffer[idx], FileObject->FileName.Length);
630 }
631 else
632 {
633 /* This is a relative open and we have only the filename, so open the parent directory
634 * It is in RelatedFileObject
635 */
636 ASSERT(FileObject->RelatedFileObject != NULL);
637
638 /* No need to modify the FO, it already has the name */
639 }
640
641 /* We're done with opening! */
642 if (ParentFcb != NULL)
643 {
644 Status = vfatAttachFCBToFileObject(DeviceExt, ParentFcb, FileObject);
645 }
646
647 if (NT_SUCCESS(Status))
648 {
649 pFcb = FileObject->FsContext;
650 ASSERT(pFcb == ParentFcb);
651
652 if (pFcb->OpenHandleCount == 0)
653 {
654 IoSetShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
655 Stack->Parameters.Create.ShareAccess,
656 FileObject,
657 &pFcb->FCBShareAccess);
658 }
659 else
660 {
661 Status = IoCheckShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
662 Stack->Parameters.Create.ShareAccess,
663 FileObject,
664 &pFcb->FCBShareAccess,
665 FALSE);
666 if (!NT_SUCCESS(Status))
667 {
668 VfatCloseFile(DeviceExt, FileObject);
669 return Status;
670 }
671 }
672
673 pFcb->OpenHandleCount++;
674 DeviceExt->OpenHandleCount++;
675 }
676 else if (ParentFcb != NULL)
677 {
678 vfatReleaseFCB(DeviceExt, ParentFcb);
679 }
680
681 return Status;
682 }
683
684 /*
685 * If the directory containing the file to open doesn't exist then
686 * fail immediately
687 */
688 if (Status == STATUS_OBJECT_PATH_NOT_FOUND ||
689 Status == STATUS_INVALID_PARAMETER ||
690 Status == STATUS_DELETE_PENDING)
691 {
692 if (ParentFcb)
693 {
694 vfatReleaseFCB(DeviceExt, ParentFcb);
695 }
696 return Status;
697 }
698
699 if (!NT_SUCCESS(Status) && ParentFcb == NULL)
700 {
701 DPRINT1("VfatOpenFile failed for '%wZ', status %x\n", &PathNameU, Status);
702 return Status;
703 }
704
705 /* If the file open failed then create the required file */
706 if (!NT_SUCCESS (Status))
707 {
708 if (RequestedDisposition == FILE_CREATE ||
709 RequestedDisposition == FILE_OPEN_IF ||
710 RequestedDisposition == FILE_OVERWRITE_IF ||
711 RequestedDisposition == FILE_SUPERSEDE)
712 {
713 Attributes = Stack->Parameters.Create.FileAttributes & ~FILE_ATTRIBUTE_NORMAL;
714 if (!(RequestedOptions & FILE_DIRECTORY_FILE))
715 Attributes |= FILE_ATTRIBUTE_ARCHIVE;
716 vfatSplitPathName(&PathNameU, NULL, &FileNameU);
717 Status = VfatAddEntry(DeviceExt, &FileNameU, &pFcb, ParentFcb, RequestedOptions,
718 (UCHAR)(Attributes & FILE_ATTRIBUTE_VALID_FLAGS), NULL);
719 vfatReleaseFCB(DeviceExt, ParentFcb);
720 if (NT_SUCCESS(Status))
721 {
722 Status = vfatAttachFCBToFileObject(DeviceExt, pFcb, FileObject);
723 if (!NT_SUCCESS(Status))
724 {
725 vfatReleaseFCB(DeviceExt, pFcb);
726 return Status;
727 }
728
729 Irp->IoStatus.Information = FILE_CREATED;
730 VfatSetAllocationSizeInformation(FileObject,
731 pFcb,
732 DeviceExt,
733 &Irp->Overlay.AllocationSize);
734 VfatSetExtendedAttributes(FileObject,
735 Irp->AssociatedIrp.SystemBuffer,
736 Stack->Parameters.Create.EaLength);
737
738 if (PagingFileCreate)
739 {
740 pFcb->Flags |= FCB_IS_PAGE_FILE;
741 }
742 }
743 else
744 {
745 return Status;
746 }
747 }
748 else
749 {
750 if (ParentFcb)
751 {
752 vfatReleaseFCB(DeviceExt, ParentFcb);
753 }
754 return Status;
755 }
756 }
757 else
758 {
759 if (ParentFcb)
760 {
761 vfatReleaseFCB(DeviceExt, ParentFcb);
762 }
763
764 /* Otherwise fail if the caller wanted to create a new file */
765 if (RequestedDisposition == FILE_CREATE)
766 {
767 Irp->IoStatus.Information = FILE_EXISTS;
768 VfatCloseFile(DeviceExt, FileObject);
769 return STATUS_OBJECT_NAME_COLLISION;
770 }
771
772 pFcb = FileObject->FsContext;
773
774 if (pFcb->OpenHandleCount != 0)
775 {
776 Status = IoCheckShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
777 Stack->Parameters.Create.ShareAccess,
778 FileObject,
779 &pFcb->FCBShareAccess,
780 FALSE);
781 if (!NT_SUCCESS(Status))
782 {
783 VfatCloseFile(DeviceExt, FileObject);
784 return Status;
785 }
786 }
787
788 /*
789 * Check the file has the requested attributes
790 */
791 if (RequestedOptions & FILE_NON_DIRECTORY_FILE &&
792 *pFcb->Attributes & FILE_ATTRIBUTE_DIRECTORY)
793 {
794 VfatCloseFile (DeviceExt, FileObject);
795 return STATUS_FILE_IS_A_DIRECTORY;
796 }
797 if (RequestedOptions & FILE_DIRECTORY_FILE &&
798 !(*pFcb->Attributes & FILE_ATTRIBUTE_DIRECTORY))
799 {
800 VfatCloseFile (DeviceExt, FileObject);
801 return STATUS_NOT_A_DIRECTORY;
802 }
803 #ifndef USE_ROS_CC_AND_FS
804 if (!(*pFcb->Attributes & FILE_ATTRIBUTE_DIRECTORY))
805 {
806 if (Stack->Parameters.Create.SecurityContext->DesiredAccess & FILE_WRITE_DATA ||
807 RequestedDisposition == FILE_OVERWRITE ||
808 RequestedDisposition == FILE_OVERWRITE_IF)
809 {
810 if (!MmFlushImageSection(&pFcb->SectionObjectPointers, MmFlushForWrite))
811 {
812 DPRINT1("%wZ\n", &pFcb->PathNameU);
813 DPRINT1("%d %d %d\n", Stack->Parameters.Create.SecurityContext->DesiredAccess & FILE_WRITE_DATA,
814 RequestedDisposition == FILE_OVERWRITE, RequestedDisposition == FILE_OVERWRITE_IF);
815 VfatCloseFile (DeviceExt, FileObject);
816 return STATUS_SHARING_VIOLATION;
817 }
818 }
819 }
820 #endif
821 if (PagingFileCreate)
822 {
823 /* FIXME:
824 * Do more checking for page files. It is possible,
825 * that the file was opened and closed previously
826 * as a normal cached file. In this case, the cache
827 * manager has referenced the fileobject and the fcb
828 * is held in memory. Try to remove the fileobject
829 * from cache manager and use the fcb.
830 */
831 if (pFcb->RefCount > 1)
832 {
833 if(!(pFcb->Flags & FCB_IS_PAGE_FILE))
834 {
835 VfatCloseFile(DeviceExt, FileObject);
836 return STATUS_INVALID_PARAMETER;
837 }
838 }
839 else
840 {
841 pFcb->Flags |= FCB_IS_PAGE_FILE;
842 }
843 }
844 else
845 {
846 if (pFcb->Flags & FCB_IS_PAGE_FILE)
847 {
848 VfatCloseFile(DeviceExt, FileObject);
849 return STATUS_INVALID_PARAMETER;
850 }
851 }
852
853 if (RequestedDisposition == FILE_OVERWRITE ||
854 RequestedDisposition == FILE_OVERWRITE_IF ||
855 RequestedDisposition == FILE_SUPERSEDE)
856 {
857 if (!(*pFcb->Attributes & FILE_ATTRIBUTE_DIRECTORY))
858 {
859 *pFcb->Attributes = Stack->Parameters.Create.FileAttributes & ~FILE_ATTRIBUTE_NORMAL;
860 *pFcb->Attributes |= FILE_ATTRIBUTE_ARCHIVE;
861 VfatUpdateEntry(pFcb);
862 }
863
864 ExAcquireResourceExclusiveLite(&(pFcb->MainResource), TRUE);
865 Status = VfatSetAllocationSizeInformation(FileObject,
866 pFcb,
867 DeviceExt,
868 &Irp->Overlay.AllocationSize);
869 ExReleaseResourceLite(&(pFcb->MainResource));
870 if (!NT_SUCCESS (Status))
871 {
872 VfatCloseFile(DeviceExt, FileObject);
873 return Status;
874 }
875 }
876
877 if (RequestedDisposition == FILE_SUPERSEDE)
878 {
879 Irp->IoStatus.Information = FILE_SUPERSEDED;
880 }
881 else if (RequestedDisposition == FILE_OVERWRITE ||
882 RequestedDisposition == FILE_OVERWRITE_IF)
883 {
884 Irp->IoStatus.Information = FILE_OVERWRITTEN;
885 }
886 else
887 {
888 Irp->IoStatus.Information = FILE_OPENED;
889 }
890 }
891
892 if (pFcb->OpenHandleCount == 0)
893 {
894 IoSetShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
895 Stack->Parameters.Create.ShareAccess,
896 FileObject,
897 &pFcb->FCBShareAccess);
898 }
899 else
900 {
901 IoUpdateShareAccess(FileObject,
902 &pFcb->FCBShareAccess);
903 }
904
905 if (Irp->IoStatus.Information == FILE_CREATED)
906 {
907 FsRtlNotifyFullReportChange(DeviceExt->NotifySync,
908 &(DeviceExt->NotifyList),
909 (PSTRING)&pFcb->PathNameU,
910 pFcb->PathNameU.Length - pFcb->LongNameU.Length,
911 NULL,
912 NULL,
913 ((*pFcb->Attributes & FILE_ATTRIBUTE_DIRECTORY) ?
914 FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME),
915 FILE_ACTION_ADDED,
916 NULL);
917 }
918
919 pFcb->OpenHandleCount++;
920 DeviceExt->OpenHandleCount++;
921
922 /* FIXME : test write access if requested */
923
924 return Status;
925 }
926
927 /*
928 * FUNCTION: Create or open a file
929 */
930 NTSTATUS
931 VfatCreate(
932 PVFAT_IRP_CONTEXT IrpContext)
933 {
934 NTSTATUS Status;
935
936 ASSERT(IrpContext);
937
938 if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
939 {
940 /* DeviceObject represents FileSystem instead of logical volume */
941 DPRINT ("FsdCreate called with file system\n");
942 IrpContext->Irp->IoStatus.Information = FILE_OPENED;
943 IrpContext->Irp->IoStatus.Status = STATUS_SUCCESS;
944 IoCompleteRequest(IrpContext->Irp, IO_DISK_INCREMENT);
945 VfatFreeIrpContext(IrpContext);
946 return STATUS_SUCCESS;
947 }
948
949 if (!(IrpContext->Flags & IRPCONTEXT_CANWAIT))
950 {
951 return(VfatQueueRequest(IrpContext));
952 }
953
954 IrpContext->Irp->IoStatus.Information = 0;
955 ExAcquireResourceExclusiveLite(&IrpContext->DeviceExt->DirResource, TRUE);
956 Status = VfatCreateFile(IrpContext->DeviceObject, IrpContext->Irp);
957 ExReleaseResourceLite(&IrpContext->DeviceExt->DirResource);
958
959 IrpContext->Irp->IoStatus.Status = Status;
960 IoCompleteRequest(IrpContext->Irp,
961 (CCHAR)(NT_SUCCESS(Status) ? IO_DISK_INCREMENT : IO_NO_INCREMENT));
962 VfatFreeIrpContext(IrpContext);
963 return Status;
964 }
965
966 /* EOF */