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