[FASTFAT] Fix size checking in VfatGetFileNameInformation()
[reactos.git] / 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 PVFATCCB pCcb = NULL;
398 PWCHAR c, last;
399 BOOLEAN PagingFileCreate;
400 BOOLEAN Dots;
401 BOOLEAN OpenTargetDir;
402 BOOLEAN TrailingBackslash;
403 UNICODE_STRING FileNameU;
404 UNICODE_STRING PathNameU;
405 ULONG Attributes;
406
407 /* Unpack the various parameters. */
408 Stack = IoGetCurrentIrpStackLocation(Irp);
409 RequestedDisposition = ((Stack->Parameters.Create.Options >> 24) & 0xff);
410 RequestedOptions = Stack->Parameters.Create.Options & FILE_VALID_OPTION_FLAGS;
411 PagingFileCreate = BooleanFlagOn(Stack->Flags, SL_OPEN_PAGING_FILE);
412 OpenTargetDir = BooleanFlagOn(Stack->Flags, SL_OPEN_TARGET_DIRECTORY);
413
414 FileObject = Stack->FileObject;
415 DeviceExt = DeviceObject->DeviceExtension;
416
417 if (BooleanFlagOn(Stack->Parameters.Create.Options, FILE_OPEN_BY_FILE_ID))
418 {
419 return STATUS_NOT_IMPLEMENTED;
420 }
421
422 /* Check their validity. */
423 if (BooleanFlagOn(RequestedOptions, FILE_DIRECTORY_FILE) &&
424 RequestedDisposition == FILE_SUPERSEDE)
425 {
426 return STATUS_INVALID_PARAMETER;
427 }
428
429 if (BooleanFlagOn(RequestedOptions, FILE_DIRECTORY_FILE) &&
430 BooleanFlagOn(RequestedOptions, FILE_NON_DIRECTORY_FILE))
431 {
432 return STATUS_INVALID_PARAMETER;
433 }
434
435 /* Deny create if the volume is locked */
436 if (BooleanFlagOn(DeviceExt->Flags, VCB_VOLUME_LOCKED))
437 {
438 return STATUS_ACCESS_DENIED;
439 }
440
441 /* This a open operation for the volume itself */
442 if (FileObject->FileName.Length == 0 &&
443 (FileObject->RelatedFileObject == NULL ||
444 FileObject->RelatedFileObject->FsContext2 != NULL ||
445 FileObject->RelatedFileObject->FsContext == DeviceExt->VolumeFcb))
446 {
447 DPRINT("Volume opening\n");
448
449 if (RequestedDisposition != FILE_OPEN &&
450 RequestedDisposition != FILE_OPEN_IF)
451 {
452 return STATUS_ACCESS_DENIED;
453 }
454
455 if (BooleanFlagOn(RequestedOptions, FILE_DIRECTORY_FILE) &&
456 (FileObject->RelatedFileObject == NULL || FileObject->RelatedFileObject->FsContext2 == NULL || FileObject->RelatedFileObject->FsContext == DeviceExt->VolumeFcb))
457 {
458 return STATUS_NOT_A_DIRECTORY;
459 }
460
461 if (OpenTargetDir)
462 {
463 return STATUS_INVALID_PARAMETER;
464 }
465
466 if (BooleanFlagOn(RequestedOptions, FILE_DELETE_ON_CLOSE))
467 {
468 return STATUS_CANNOT_DELETE;
469 }
470
471 vfatAddToStat(DeviceExt, Fat.CreateHits, 1);
472
473 pFcb = DeviceExt->VolumeFcb;
474
475 if (pFcb->OpenHandleCount == 0)
476 {
477 IoSetShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
478 Stack->Parameters.Create.ShareAccess,
479 FileObject,
480 &pFcb->FCBShareAccess);
481 }
482 else
483 {
484 Status = IoCheckShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
485 Stack->Parameters.Create.ShareAccess,
486 FileObject,
487 &pFcb->FCBShareAccess,
488 FALSE);
489 if (!NT_SUCCESS(Status))
490 {
491 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
492 return Status;
493 }
494 }
495
496 vfatAttachFCBToFileObject(DeviceExt, pFcb, FileObject);
497 DeviceExt->OpenHandleCount++;
498 pFcb->OpenHandleCount++;
499 vfatAddToStat(DeviceExt, Fat.SuccessfulCreates, 1);
500
501 Irp->IoStatus.Information = FILE_OPENED;
502 return STATUS_SUCCESS;
503 }
504
505 if (FileObject->RelatedFileObject != NULL &&
506 FileObject->RelatedFileObject->FsContext == DeviceExt->VolumeFcb)
507 {
508 ASSERT(FileObject->FileName.Length != 0);
509 return STATUS_OBJECT_PATH_NOT_FOUND;
510 }
511
512 /* Check for illegal characters and illegal dot sequences in the file name */
513 PathNameU = FileObject->FileName;
514 c = PathNameU.Buffer + PathNameU.Length / sizeof(WCHAR);
515 last = c - 1;
516
517 Dots = TRUE;
518 while (c-- > PathNameU.Buffer)
519 {
520 if (*c == L'\\' || c == PathNameU.Buffer)
521 {
522 if (Dots && last > c)
523 {
524 return STATUS_OBJECT_NAME_INVALID;
525 }
526 if (*c == L'\\' && (c - 1) > PathNameU.Buffer &&
527 *(c - 1) == L'\\')
528 {
529 return STATUS_OBJECT_NAME_INVALID;
530 }
531
532 last = c - 1;
533 Dots = TRUE;
534 }
535 else if (*c != L'.')
536 {
537 Dots = FALSE;
538 }
539
540 if (*c != '\\' && vfatIsLongIllegal(*c))
541 {
542 return STATUS_OBJECT_NAME_INVALID;
543 }
544 }
545
546 /* Check if we try to open target directory of root dir */
547 if (OpenTargetDir && FileObject->RelatedFileObject == NULL && PathNameU.Length == sizeof(WCHAR) &&
548 PathNameU.Buffer[0] == L'\\')
549 {
550 return STATUS_INVALID_PARAMETER;
551 }
552
553 if (FileObject->RelatedFileObject && PathNameU.Length >= sizeof(WCHAR) && PathNameU.Buffer[0] == L'\\')
554 {
555 return STATUS_OBJECT_NAME_INVALID;
556 }
557
558 TrailingBackslash = FALSE;
559 if (PathNameU.Length > sizeof(WCHAR) && PathNameU.Buffer[PathNameU.Length/sizeof(WCHAR)-1] == L'\\')
560 {
561 PathNameU.Length -= sizeof(WCHAR);
562 TrailingBackslash = TRUE;
563 }
564
565 if (PathNameU.Length > sizeof(WCHAR) && PathNameU.Buffer[PathNameU.Length/sizeof(WCHAR)-1] == L'\\')
566 {
567 return STATUS_OBJECT_NAME_INVALID;
568 }
569
570 /* Try opening the file. */
571 if (!OpenTargetDir)
572 {
573 vfatAddToStat(DeviceExt, Fat.CreateHits, 1);
574
575 Status = VfatOpenFile(DeviceExt, &PathNameU, FileObject, RequestedDisposition, RequestedOptions, &ParentFcb);
576 }
577 else
578 {
579 PVFATFCB TargetFcb;
580 LONG idx, FileNameLen;
581
582 vfatAddToStat(DeviceExt, Fat.CreateHits, 1);
583
584 ParentFcb = (FileObject->RelatedFileObject != NULL) ? FileObject->RelatedFileObject->FsContext : NULL;
585 if (ParentFcb)
586 {
587 vfatGrabFCB(DeviceExt, ParentFcb);
588 }
589
590 Status = vfatGetFCBForFile(DeviceExt, &ParentFcb, &TargetFcb, &PathNameU);
591 if (NT_SUCCESS(Status))
592 {
593 vfatReleaseFCB(DeviceExt, TargetFcb);
594 Irp->IoStatus.Information = FILE_EXISTS;
595 }
596 else
597 {
598 Irp->IoStatus.Information = FILE_DOES_NOT_EXIST;
599 }
600
601 idx = FileObject->FileName.Length / sizeof(WCHAR) - 1;
602
603 /* Skip trailing \ - if any */
604 if (PathNameU.Buffer[idx] == L'\\')
605 {
606 --idx;
607 PathNameU.Length -= sizeof(WCHAR);
608 }
609
610 /* Get file name */
611 while (idx >= 0 && PathNameU.Buffer[idx] != L'\\')
612 {
613 --idx;
614 }
615
616 if (idx > 0 || PathNameU.Buffer[0] == L'\\')
617 {
618 /* We don't want to include / in the name */
619 FileNameLen = PathNameU.Length - ((idx + 1) * sizeof(WCHAR));
620
621 /* Update FO just to keep file name */
622 /* Skip first slash */
623 ++idx;
624 FileObject->FileName.Length = FileNameLen;
625 RtlMoveMemory(&PathNameU.Buffer[0], &PathNameU.Buffer[idx], FileObject->FileName.Length);
626 #if 0
627 /* Terminate the string at the last backslash */
628 PathNameU.Buffer[idx + 1] = UNICODE_NULL;
629 PathNameU.Length = (idx + 1) * sizeof(WCHAR);
630 PathNameU.MaximumLength = PathNameU.Length + sizeof(WCHAR);
631
632 /* Update the file object as well */
633 FileObject->FileName.Length = PathNameU.Length;
634 FileObject->FileName.MaximumLength = PathNameU.MaximumLength;
635 #endif
636 }
637 else
638 {
639 /* This is a relative open and we have only the filename, so open the parent directory
640 * It is in RelatedFileObject
641 */
642 ASSERT(FileObject->RelatedFileObject != NULL);
643
644 /* No need to modify the FO, it already has the name */
645 }
646
647 /* We're done with opening! */
648 if (ParentFcb != NULL)
649 {
650 Status = vfatAttachFCBToFileObject(DeviceExt, ParentFcb, FileObject);
651 }
652
653 if (NT_SUCCESS(Status))
654 {
655 pFcb = FileObject->FsContext;
656 ASSERT(pFcb == ParentFcb);
657
658 if (pFcb->OpenHandleCount == 0)
659 {
660 IoSetShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
661 Stack->Parameters.Create.ShareAccess,
662 FileObject,
663 &pFcb->FCBShareAccess);
664 }
665 else
666 {
667 Status = IoCheckShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
668 Stack->Parameters.Create.ShareAccess,
669 FileObject,
670 &pFcb->FCBShareAccess,
671 FALSE);
672 if (!NT_SUCCESS(Status))
673 {
674 VfatCloseFile(DeviceExt, FileObject);
675 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
676 return Status;
677 }
678 }
679
680 pCcb = FileObject->FsContext2;
681 if (BooleanFlagOn(RequestedOptions, FILE_DELETE_ON_CLOSE))
682 {
683 pCcb->Flags |= CCB_DELETE_ON_CLOSE;
684 }
685
686 pFcb->OpenHandleCount++;
687 DeviceExt->OpenHandleCount++;
688 }
689 else if (ParentFcb != NULL)
690 {
691 vfatReleaseFCB(DeviceExt, ParentFcb);
692 }
693
694 if (NT_SUCCESS(Status))
695 {
696 vfatAddToStat(DeviceExt, Fat.SuccessfulCreates, 1);
697 }
698 else
699 {
700 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
701 }
702
703 return Status;
704 }
705
706 /*
707 * If the directory containing the file to open doesn't exist then
708 * fail immediately
709 */
710 if (Status == STATUS_OBJECT_PATH_NOT_FOUND ||
711 Status == STATUS_INVALID_PARAMETER ||
712 Status == STATUS_DELETE_PENDING ||
713 Status == STATUS_ACCESS_DENIED ||
714 Status == STATUS_OBJECT_NAME_COLLISION)
715 {
716 if (ParentFcb)
717 {
718 vfatReleaseFCB(DeviceExt, ParentFcb);
719 }
720 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
721 return Status;
722 }
723
724 if (!NT_SUCCESS(Status) && ParentFcb == NULL)
725 {
726 DPRINT1("VfatOpenFile failed for '%wZ', status %x\n", &PathNameU, Status);
727 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
728 return Status;
729 }
730
731 /* If the file open failed then create the required file */
732 if (!NT_SUCCESS (Status))
733 {
734 if (RequestedDisposition == FILE_CREATE ||
735 RequestedDisposition == FILE_OPEN_IF ||
736 RequestedDisposition == FILE_OVERWRITE_IF ||
737 RequestedDisposition == FILE_SUPERSEDE)
738 {
739 Attributes = Stack->Parameters.Create.FileAttributes & ~FILE_ATTRIBUTE_NORMAL;
740 if (!BooleanFlagOn(RequestedOptions, FILE_DIRECTORY_FILE))
741 {
742 if (TrailingBackslash)
743 {
744 vfatReleaseFCB(DeviceExt, ParentFcb);
745 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
746 return STATUS_OBJECT_NAME_INVALID;
747 }
748 Attributes |= FILE_ATTRIBUTE_ARCHIVE;
749 }
750 vfatSplitPathName(&PathNameU, NULL, &FileNameU);
751 Status = VfatAddEntry(DeviceExt, &FileNameU, &pFcb, ParentFcb, RequestedOptions,
752 (UCHAR)FlagOn(Attributes, FILE_ATTRIBUTE_VALID_FLAGS), NULL);
753 vfatReleaseFCB(DeviceExt, ParentFcb);
754 if (NT_SUCCESS(Status))
755 {
756 Status = vfatAttachFCBToFileObject(DeviceExt, pFcb, FileObject);
757 if (!NT_SUCCESS(Status))
758 {
759 vfatReleaseFCB(DeviceExt, pFcb);
760 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
761 return Status;
762 }
763
764 Irp->IoStatus.Information = FILE_CREATED;
765 VfatSetAllocationSizeInformation(FileObject,
766 pFcb,
767 DeviceExt,
768 &Irp->Overlay.AllocationSize);
769 VfatSetExtendedAttributes(FileObject,
770 Irp->AssociatedIrp.SystemBuffer,
771 Stack->Parameters.Create.EaLength);
772
773 if (PagingFileCreate)
774 {
775 pFcb->Flags |= FCB_IS_PAGE_FILE;
776 }
777 }
778 else
779 {
780 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
781 return Status;
782 }
783 }
784 else
785 {
786 vfatReleaseFCB(DeviceExt, ParentFcb);
787 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
788 return Status;
789 }
790 }
791 else
792 {
793 if (ParentFcb)
794 {
795 vfatReleaseFCB(DeviceExt, ParentFcb);
796 }
797
798 pFcb = FileObject->FsContext;
799
800 /* Otherwise fail if the caller wanted to create a new file */
801 if (RequestedDisposition == FILE_CREATE)
802 {
803 VfatCloseFile(DeviceExt, FileObject);
804 if (TrailingBackslash && !vfatFCBIsDirectory(pFcb))
805 {
806 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
807 return STATUS_OBJECT_NAME_INVALID;
808 }
809 Irp->IoStatus.Information = FILE_EXISTS;
810 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
811 return STATUS_OBJECT_NAME_COLLISION;
812 }
813
814 if (pFcb->OpenHandleCount != 0)
815 {
816 Status = IoCheckShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
817 Stack->Parameters.Create.ShareAccess,
818 FileObject,
819 &pFcb->FCBShareAccess,
820 FALSE);
821 if (!NT_SUCCESS(Status))
822 {
823 VfatCloseFile(DeviceExt, FileObject);
824 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
825 return Status;
826 }
827 }
828
829 /*
830 * Check the file has the requested attributes
831 */
832 if (BooleanFlagOn(RequestedOptions, FILE_NON_DIRECTORY_FILE) &&
833 vfatFCBIsDirectory(pFcb))
834 {
835 VfatCloseFile (DeviceExt, FileObject);
836 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
837 return STATUS_FILE_IS_A_DIRECTORY;
838 }
839 if (BooleanFlagOn(RequestedOptions, FILE_DIRECTORY_FILE) &&
840 !vfatFCBIsDirectory(pFcb))
841 {
842 VfatCloseFile (DeviceExt, FileObject);
843 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
844 return STATUS_NOT_A_DIRECTORY;
845 }
846 if (TrailingBackslash && !vfatFCBIsDirectory(pFcb))
847 {
848 VfatCloseFile (DeviceExt, FileObject);
849 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
850 return STATUS_OBJECT_NAME_INVALID;
851 }
852 #ifndef USE_ROS_CC_AND_FS
853 if (!vfatFCBIsDirectory(pFcb))
854 {
855 if (BooleanFlagOn(Stack->Parameters.Create.SecurityContext->DesiredAccess, FILE_WRITE_DATA) ||
856 RequestedDisposition == FILE_OVERWRITE ||
857 RequestedDisposition == FILE_OVERWRITE_IF ||
858 (RequestedOptions & FILE_DELETE_ON_CLOSE))
859 {
860 if (!MmFlushImageSection(&pFcb->SectionObjectPointers, MmFlushForWrite))
861 {
862 DPRINT1("%wZ\n", &pFcb->PathNameU);
863 DPRINT1("%d %d %d\n", Stack->Parameters.Create.SecurityContext->DesiredAccess & FILE_WRITE_DATA,
864 RequestedDisposition == FILE_OVERWRITE, RequestedDisposition == FILE_OVERWRITE_IF);
865 VfatCloseFile (DeviceExt, FileObject);
866 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
867 return (BooleanFlagOn(RequestedOptions, FILE_DELETE_ON_CLOSE)) ? STATUS_CANNOT_DELETE
868 : STATUS_SHARING_VIOLATION;
869 }
870 }
871 }
872 #endif
873 if (PagingFileCreate)
874 {
875 /* FIXME:
876 * Do more checking for page files. It is possible,
877 * that the file was opened and closed previously
878 * as a normal cached file. In this case, the cache
879 * manager has referenced the fileobject and the fcb
880 * is held in memory. Try to remove the fileobject
881 * from cache manager and use the fcb.
882 */
883 if (pFcb->RefCount > 1)
884 {
885 if(!BooleanFlagOn(pFcb->Flags, FCB_IS_PAGE_FILE))
886 {
887 VfatCloseFile(DeviceExt, FileObject);
888 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
889 return STATUS_INVALID_PARAMETER;
890 }
891 }
892 else
893 {
894 pFcb->Flags |= FCB_IS_PAGE_FILE;
895 }
896 }
897 else
898 {
899 if (BooleanFlagOn(pFcb->Flags, FCB_IS_PAGE_FILE))
900 {
901 VfatCloseFile(DeviceExt, FileObject);
902 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
903 return STATUS_INVALID_PARAMETER;
904 }
905 }
906
907 if (RequestedDisposition == FILE_OVERWRITE ||
908 RequestedDisposition == FILE_OVERWRITE_IF ||
909 RequestedDisposition == FILE_SUPERSEDE)
910 {
911 if (!vfatFCBIsDirectory(pFcb))
912 {
913 *pFcb->Attributes = Stack->Parameters.Create.FileAttributes & ~FILE_ATTRIBUTE_NORMAL;
914 *pFcb->Attributes |= FILE_ATTRIBUTE_ARCHIVE;
915 VfatUpdateEntry(pFcb, vfatVolumeIsFatX(DeviceExt));
916 }
917
918 ExAcquireResourceExclusiveLite(&(pFcb->MainResource), TRUE);
919 Status = VfatSetAllocationSizeInformation(FileObject,
920 pFcb,
921 DeviceExt,
922 &Irp->Overlay.AllocationSize);
923 ExReleaseResourceLite(&(pFcb->MainResource));
924 if (!NT_SUCCESS (Status))
925 {
926 VfatCloseFile(DeviceExt, FileObject);
927 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
928 return Status;
929 }
930 }
931
932 if (RequestedDisposition == FILE_SUPERSEDE)
933 {
934 Irp->IoStatus.Information = FILE_SUPERSEDED;
935 }
936 else if (RequestedDisposition == FILE_OVERWRITE ||
937 RequestedDisposition == FILE_OVERWRITE_IF)
938 {
939 Irp->IoStatus.Information = FILE_OVERWRITTEN;
940 }
941 else
942 {
943 Irp->IoStatus.Information = FILE_OPENED;
944 }
945 }
946
947 if (pFcb->OpenHandleCount == 0)
948 {
949 IoSetShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
950 Stack->Parameters.Create.ShareAccess,
951 FileObject,
952 &pFcb->FCBShareAccess);
953 }
954 else
955 {
956 IoUpdateShareAccess(FileObject,
957 &pFcb->FCBShareAccess);
958 }
959
960 pCcb = FileObject->FsContext2;
961 if (BooleanFlagOn(RequestedOptions, FILE_DELETE_ON_CLOSE))
962 {
963 pCcb->Flags |= CCB_DELETE_ON_CLOSE;
964 }
965
966 if (Irp->IoStatus.Information == FILE_CREATED)
967 {
968 FsRtlNotifyFullReportChange(DeviceExt->NotifySync,
969 &(DeviceExt->NotifyList),
970 (PSTRING)&pFcb->PathNameU,
971 pFcb->PathNameU.Length - pFcb->LongNameU.Length,
972 NULL,
973 NULL,
974 (vfatFCBIsDirectory(pFcb) ?
975 FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME),
976 FILE_ACTION_ADDED,
977 NULL);
978 }
979
980 pFcb->OpenHandleCount++;
981 DeviceExt->OpenHandleCount++;
982
983 /* FIXME : test write access if requested */
984
985 if (NT_SUCCESS(Status))
986 {
987 vfatAddToStat(DeviceExt, Fat.SuccessfulCreates, 1);
988 }
989 else
990 {
991 vfatAddToStat(DeviceExt, Fat.FailedCreates, 1);
992 }
993
994 return Status;
995 }
996
997 /*
998 * FUNCTION: Create or open a file
999 */
1000 NTSTATUS
1001 VfatCreate(
1002 PVFAT_IRP_CONTEXT IrpContext)
1003 {
1004 NTSTATUS Status;
1005
1006 ASSERT(IrpContext);
1007
1008 if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
1009 {
1010 /* DeviceObject represents FileSystem instead of logical volume */
1011 DPRINT ("FsdCreate called with file system\n");
1012 IrpContext->Irp->IoStatus.Information = FILE_OPENED;
1013 IrpContext->PriorityBoost = IO_DISK_INCREMENT;
1014
1015 return STATUS_SUCCESS;
1016 }
1017
1018 if (!BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT))
1019 {
1020 return VfatMarkIrpContextForQueue(IrpContext);
1021 }
1022
1023 IrpContext->Irp->IoStatus.Information = 0;
1024 ExAcquireResourceExclusiveLite(&IrpContext->DeviceExt->DirResource, TRUE);
1025 Status = VfatCreateFile(IrpContext->DeviceObject, IrpContext->Irp);
1026 ExReleaseResourceLite(&IrpContext->DeviceExt->DirResource);
1027
1028 if (NT_SUCCESS(Status))
1029 IrpContext->PriorityBoost = IO_DISK_INCREMENT;
1030
1031 return Status;
1032 }
1033
1034 /* EOF */