projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Synchronize with trunk r58528.
[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/fs/vfat/create.c
22 * PURPOSE: VFAT Filesystem
23 * PROGRAMMER: Jason Filby (jasonfilby@yahoo.com)
24 */
25
26 /* INCLUDES *****************************************************************/
27
28 #define NDEBUG
29 #include "vfat.h"
30
31 /* FUNCTIONS *****************************************************************/
32
33 void
34 vfat8Dot3ToString (PFAT_DIR_ENTRY pEntry, PUNICODE_STRING NameU)
35 {
36 OEM_STRING StringA;
37 USHORT Length;
38 CHAR cString[12];
39
40 RtlCopyMemory(cString, pEntry->ShortName, 11);
41 cString[11] = 0;
42 if (cString[0] == 0x05)
43 {
44 cString[0] = 0xe5;
45 }
46
47 StringA.Buffer = cString;
48 for (StringA.Length = 0;
49 StringA.Length < 8 && StringA.Buffer[StringA.Length] != ' ';
50 StringA.Length++);
51 StringA.MaximumLength = StringA.Length;
52
53 RtlOemStringToUnicodeString(NameU, &StringA, FALSE);
54
55 if (pEntry->lCase & VFAT_CASE_LOWER_BASE)
56 {
57 RtlDowncaseUnicodeString(NameU, NameU, FALSE);
58 }
59 if (cString[8] != ' ')
60 {
61 Length = NameU->Length;
62 NameU->Buffer += Length / sizeof(WCHAR);
63 if (!FAT_ENTRY_VOLUME(pEntry))
64 {
65 Length += sizeof(WCHAR);
66 NameU->Buffer[0] = L'.';
67 NameU->Buffer++;
68 }
69 NameU->Length = 0;
70 NameU->MaximumLength -= Length;
71
72 StringA.Buffer = &cString[8];
73 for (StringA.Length = 0;
74 StringA.Length < 3 && StringA.Buffer[StringA.Length] != ' ';
75 StringA.Length++);
76 StringA.MaximumLength = StringA.Length;
77 RtlOemStringToUnicodeString(NameU, &StringA, FALSE);
78 if (pEntry->lCase & VFAT_CASE_LOWER_EXT)
79 {
80 RtlDowncaseUnicodeString(NameU, NameU, FALSE);
81 }
82 NameU->Buffer -= Length / sizeof(WCHAR);
83 NameU->Length += Length;
84 NameU->MaximumLength += Length;
85 }
86 NameU->Buffer[NameU->Length / sizeof(WCHAR)] = 0;
87 DPRINT("'%wZ'\n", NameU);
88 }
89
90 NTSTATUS
91 ReadVolumeLabel (PDEVICE_EXTENSION DeviceExt, PVPB Vpb)
92 /*
93 * FUNCTION: Read the volume label
94 */
95 {
96 PVOID Context = NULL;
97 ULONG DirIndex = 0;
98 PDIR_ENTRY Entry;
99 PVFATFCB pFcb;
100 LARGE_INTEGER FileOffset;
101 UNICODE_STRING NameU;
102 ULONG SizeDirEntry;
103 ULONG EntriesPerPage;
104 OEM_STRING StringO;
105
106 NameU.Buffer = Vpb->VolumeLabel;
107 NameU.Length = 0;
108 NameU.MaximumLength = sizeof(Vpb->VolumeLabel);
109 *(Vpb->VolumeLabel) = 0;
110 Vpb->VolumeLabelLength = 0;
111
112 if (DeviceExt->Flags & VCB_IS_FATX)
113 {
114 SizeDirEntry = sizeof(FATX_DIR_ENTRY);
115 EntriesPerPage = FATX_ENTRIES_PER_PAGE;
116 }
117 else
118 {
119 SizeDirEntry = sizeof(FAT_DIR_ENTRY);
120 EntriesPerPage = FAT_ENTRIES_PER_PAGE;
121 }
122
123 ExAcquireResourceExclusiveLite (&DeviceExt->DirResource, TRUE);
124 pFcb = vfatOpenRootFCB (DeviceExt);
125 ExReleaseResourceLite (&DeviceExt->DirResource);
126
127 FileOffset.QuadPart = 0;
128 if (CcMapData(pFcb->FileObject, &FileOffset, SizeDirEntry, TRUE, &Context, (PVOID*)&Entry))
129 {
130 while (TRUE)
131 {
132 if (ENTRY_VOLUME(DeviceExt, Entry))
133 {
134 /* copy volume label */
135 if (DeviceExt->Flags & VCB_IS_FATX)
136 {
137 StringO.Buffer = (PCHAR)Entry->FatX.Filename;
138 StringO.MaximumLength = StringO.Length = Entry->FatX.FilenameLength;
139 RtlOemStringToUnicodeString(&NameU, &StringO, FALSE);
140 }
141 else
142 {
143 vfat8Dot3ToString (&Entry->Fat, &NameU);
144 }
145 Vpb->VolumeLabelLength = NameU.Length;
146 break;
147 }
148 if (ENTRY_END(DeviceExt, Entry))
149 {
150 break;
151 }
152 DirIndex++;
153 Entry = (PDIR_ENTRY)((ULONG_PTR)Entry + SizeDirEntry);
154 if ((DirIndex % EntriesPerPage) == 0)
155 {
156 CcUnpinData(Context);
157 FileOffset.u.LowPart += PAGE_SIZE;
158 if (!CcMapData(pFcb->FileObject, &FileOffset, SizeDirEntry, TRUE, &Context, (PVOID*)&Entry))
159 {
160 Context = NULL;
161 break;
162 }
163 }
164 }
165 if (Context)
166 {
167 CcUnpinData(Context);
168 }
169 }
170 ExAcquireResourceExclusiveLite (&DeviceExt->DirResource, TRUE);
171 vfatReleaseFCB (DeviceExt, pFcb);
172 ExReleaseResourceLite (&DeviceExt->DirResource);
173
174 return STATUS_SUCCESS;
175 }
176
177 NTSTATUS
178 FindFile (
179 PDEVICE_EXTENSION DeviceExt,
180 PVFATFCB Parent,
181 PUNICODE_STRING FileToFindU,
182 PVFAT_DIRENTRY_CONTEXT DirContext,
183 BOOLEAN First)
184 /*
185 * FUNCTION: Find a file
186 */
187 {
188 PWCHAR PathNameBuffer;
189 USHORT PathNameBufferLength;
190 NTSTATUS Status;
191 PVOID Context = NULL;
192 PVOID Page;
193 PVFATFCB rcFcb;
194 BOOLEAN Found;
195 UNICODE_STRING PathNameU;
196 UNICODE_STRING FileToFindUpcase;
197 BOOLEAN WildCard;
198
199 DPRINT ("FindFile(Parent %p, FileToFind '%wZ', DirIndex: %d)\n",
200 Parent, FileToFindU, DirContext->DirIndex);
201 DPRINT ("FindFile: Path %wZ\n",&Parent->PathNameU);
202
203 PathNameBufferLength = LONGNAME_MAX_LENGTH * sizeof(WCHAR);
204 PathNameBuffer = ExAllocatePoolWithTag(NonPagedPool, PathNameBufferLength + sizeof(WCHAR), TAG_VFAT);
205 if (!PathNameBuffer)
206 {
207 return STATUS_INSUFFICIENT_RESOURCES;
208 }
209
210 PathNameU.Buffer = PathNameBuffer;
211 PathNameU.Length = 0;
212 PathNameU.MaximumLength = PathNameBufferLength;
213
214 DirContext->LongNameU.Length = 0;
215 DirContext->ShortNameU.Length = 0;
216
217 WildCard = FsRtlDoesNameContainWildCards(FileToFindU);
218
219 if (WildCard == FALSE)
220 {
221 /* if there is no '*?' in the search name, than look first for an existing fcb */
222 RtlCopyUnicodeString(&PathNameU, &Parent->PathNameU);
223 if (!vfatFCBIsRoot(Parent))
224 {
225 PathNameU.Buffer[PathNameU.Length / sizeof(WCHAR)] = L'\\';
226 PathNameU.Length += sizeof(WCHAR);
227 }
228 RtlAppendUnicodeStringToString(&PathNameU, FileToFindU);
229 PathNameU.Buffer[PathNameU.Length / sizeof(WCHAR)] = 0;
230 rcFcb = vfatGrabFCBFromTable(DeviceExt, &PathNameU);
231 if (rcFcb)
232 {
233 ULONG startIndex = rcFcb->startIndex;
234 if ((rcFcb->Flags & FCB_IS_FATX_ENTRY) && !vfatFCBIsRoot(Parent))
235 {
236 startIndex += 2;
237 }
238 if(startIndex >= DirContext->DirIndex)
239 {
240 RtlCopyUnicodeString(&DirContext->LongNameU, &rcFcb->LongNameU);
241 RtlCopyUnicodeString(&DirContext->ShortNameU, &rcFcb->ShortNameU);
242 RtlCopyMemory(&DirContext->DirEntry, &rcFcb->entry, sizeof(DIR_ENTRY));
243 DirContext->StartIndex = rcFcb->startIndex;
244 DirContext->DirIndex = rcFcb->dirIndex;
245 DPRINT("FindFile: new Name %wZ, DirIndex %d (%d)\n",
246 &DirContext->LongNameU, DirContext->DirIndex, DirContext->StartIndex);
247 Status = STATUS_SUCCESS;
248 }
249 else
250 {
251 DPRINT("FCB not found for %wZ\n", &PathNameU);
252 Status = STATUS_UNSUCCESSFUL;
253 }
254 vfatReleaseFCB(DeviceExt, rcFcb);
255 ExFreePool(PathNameBuffer);
256 return Status;
257 }
258 }
259
260 /* FsRtlIsNameInExpression need the searched string to be upcase,
261 * even if IgnoreCase is specified */
262 Status = RtlUpcaseUnicodeString(&FileToFindUpcase, FileToFindU, TRUE);
263 if (!NT_SUCCESS(Status))
264 {
265 ExFreePool(PathNameBuffer);
266 return Status;
267 }
268
269 while(TRUE)
270 {
271 Status = DeviceExt->GetNextDirEntry(&Context, &Page, Parent, DirContext, First);
272 First = FALSE;
273 if (Status == STATUS_NO_MORE_ENTRIES)
274 {
275 break;
276 }
277 if (ENTRY_VOLUME(DeviceExt, &DirContext->DirEntry))
278 {
279 DirContext->DirIndex++;
280 continue;
281 }
282 if (WildCard)
283 {
284 Found = FsRtlIsNameInExpression(&FileToFindUpcase, &DirContext->LongNameU, TRUE, NULL) ||
285 FsRtlIsNameInExpression(&FileToFindUpcase, &DirContext->ShortNameU, TRUE, NULL);
286 }
287 else
288 {
289 Found = FsRtlAreNamesEqual(&DirContext->LongNameU, FileToFindU, TRUE, NULL) ||
290 FsRtlAreNamesEqual(&DirContext->ShortNameU, FileToFindU, TRUE, NULL);
291 }
292
293 if (Found)
294 {
295 if (WildCard)
296 {
297 RtlCopyUnicodeString(&PathNameU, &Parent->PathNameU);
298 if (!vfatFCBIsRoot(Parent))
299 {
300 PathNameU.Buffer[PathNameU.Length / sizeof(WCHAR)] = L'\\';
301 PathNameU.Length += sizeof(WCHAR);
302 }
303 RtlAppendUnicodeStringToString(&PathNameU, &DirContext->LongNameU);
304 PathNameU.Buffer[PathNameU.Length / sizeof(WCHAR)] = 0;
305 rcFcb = vfatGrabFCBFromTable(DeviceExt, &PathNameU);
306 if (rcFcb != NULL)
307 {
308 RtlCopyMemory(&DirContext->DirEntry, &rcFcb->entry, sizeof(DIR_ENTRY));
309 vfatReleaseFCB(DeviceExt, rcFcb);
310 }
311 }
312 DPRINT("%d\n", DirContext->LongNameU.Length);
313 DPRINT("FindFile: new Name %wZ, DirIndex %d\n",
314 &DirContext->LongNameU, DirContext->DirIndex);
315
316 if (Context)
317 {
318 CcUnpinData(Context);
319 }
320 RtlFreeUnicodeString(&FileToFindUpcase);
321 ExFreePool(PathNameBuffer);
322 return STATUS_SUCCESS;
323 }
324 DirContext->DirIndex++;
325 }
326
327 if (Context)
328 {
329 CcUnpinData(Context);
330 }
331
332 RtlFreeUnicodeString(&FileToFindUpcase);
333 ExFreePool(PathNameBuffer);
334 return Status;
335 }
336
337 static
338 NTSTATUS
339 VfatOpenFile (
340 PDEVICE_EXTENSION DeviceExt,
341 PUNICODE_STRING PathNameU,
342 PFILE_OBJECT FileObject,
343 PVFATFCB* ParentFcb )
344 /*
345 * FUNCTION: Opens a file
346 */
347 {
348 PVFATFCB Fcb;
349 NTSTATUS Status;
350
351 DPRINT ("VfatOpenFile(%p, '%wZ', %p, %p)\n", DeviceExt, PathNameU, FileObject, ParentFcb);
352
353 if (FileObject->RelatedFileObject)
354 {
355 DPRINT ("'%wZ'\n", &FileObject->RelatedFileObject->FileName);
356
357 *ParentFcb = FileObject->RelatedFileObject->FsContext;
358 (*ParentFcb)->RefCount++;
359 }
360 else
361 {
362 *ParentFcb = NULL;
363 }
364
365 if (!DeviceExt->FatInfo.FixedMedia)
366 {
367 Status = VfatBlockDeviceIoControl (DeviceExt->StorageDevice,
368 IOCTL_DISK_CHECK_VERIFY,
369 NULL,
370 0,
371 NULL,
372 0,
373 FALSE);
374
375 if (!NT_SUCCESS(Status))
376 {
377 DPRINT ("Status %lx\n", Status);
378 *ParentFcb = NULL;
379 return Status;
380 }
381 }
382
383 if (*ParentFcb)
384 {
385 (*ParentFcb)->RefCount++;
386 }
387
388 /* try first to find an existing FCB in memory */
389 DPRINT ("Checking for existing FCB in memory\n");
390
391 Status = vfatGetFCBForFile (DeviceExt, ParentFcb, &Fcb, PathNameU);
392 if (!NT_SUCCESS (Status))
393 {
394 DPRINT ("Could not make a new FCB, status: %x\n", Status);
395 return Status;
396 }
397 if (Fcb->Flags & FCB_DELETE_PENDING)
398 {
399 vfatReleaseFCB (DeviceExt, Fcb);
400 return STATUS_DELETE_PENDING;
401 }
402 DPRINT ("Attaching FCB to fileObject\n");
403 Status = vfatAttachFCBToFileObject (DeviceExt, Fcb, FileObject);
404 if (!NT_SUCCESS(Status))
405 {
406 vfatReleaseFCB (DeviceExt, Fcb);
407 }
408 return Status;
409 }
410
411 static NTSTATUS
412 VfatCreateFile ( PDEVICE_OBJECT DeviceObject, PIRP Irp )
413 /*
414 * FUNCTION: Create or open a file
415 */
416 {
417 PIO_STACK_LOCATION Stack;
418 PFILE_OBJECT FileObject;
419 NTSTATUS Status = STATUS_SUCCESS;
420 PDEVICE_EXTENSION DeviceExt;
421 ULONG RequestedDisposition, RequestedOptions;
422 PVFATFCB pFcb = NULL;
423 PVFATFCB ParentFcb = NULL;
424 PWCHAR c, last;
425 BOOLEAN PagingFileCreate = FALSE;
426 BOOLEAN Dots;
427 UNICODE_STRING FileNameU;
428 UNICODE_STRING PathNameU;
429
430 /* Unpack the various parameters. */
431 Stack = IoGetCurrentIrpStackLocation (Irp);
432 RequestedDisposition = ((Stack->Parameters.Create.Options >> 24) & 0xff);
433 RequestedOptions =
434 Stack->Parameters.Create.Options & FILE_VALID_OPTION_FLAGS;
435 PagingFileCreate = (Stack->Flags & SL_OPEN_PAGING_FILE) ? TRUE : FALSE;
436 FileObject = Stack->FileObject;
437 DeviceExt = DeviceObject->DeviceExtension;
438
439 /* Check their validity. */
440 if (RequestedOptions & FILE_DIRECTORY_FILE &&
441 RequestedDisposition == FILE_SUPERSEDE)
442 {
443 return(STATUS_INVALID_PARAMETER);
444 }
445
446 if (RequestedOptions & FILE_DIRECTORY_FILE &&
447 RequestedOptions & FILE_NON_DIRECTORY_FILE)
448 {
449 return(STATUS_INVALID_PARAMETER);
450 }
451
452 /* This a open operation for the volume itself */
453 if (FileObject->FileName.Length == 0 &&
454 (FileObject->RelatedFileObject == NULL || FileObject->RelatedFileObject->FsContext2 != NULL))
455 {
456 if (RequestedDisposition != FILE_OPEN &&
457 RequestedDisposition != FILE_OPEN_IF)
458 {
459 return(STATUS_ACCESS_DENIED);
460 }
461 #if 0
462 /* In spite of what is shown in WDK, it seems that Windows FAT driver doesn't perform that test */
463 if (RequestedOptions & FILE_DIRECTORY_FILE)
464 {
465 return(STATUS_NOT_A_DIRECTORY);
466 }
467 #endif
468
469 pFcb = DeviceExt->VolumeFcb;
470 vfatAttachFCBToFileObject(DeviceExt, pFcb, FileObject);
471 pFcb->RefCount++;
472
473 Irp->IoStatus.Information = FILE_OPENED;
474 return(STATUS_SUCCESS);
475 }
476
477 /*
478 * Check for illegal characters and illegale dot sequences in the file name
479 */
480 PathNameU = FileObject->FileName;
481 c = PathNameU.Buffer + PathNameU.Length / sizeof(WCHAR);
482 last = c - 1;
483 Dots = TRUE;
484 while (c-- > PathNameU.Buffer)
485 {
486 if (*c == L'\\' || c == PathNameU.Buffer)
487 {
488 if (Dots && last > c)
489 {
490 return(STATUS_OBJECT_NAME_INVALID);
491 }
492 last = c - 1;
493 Dots = TRUE;
494 }
495 else if (*c != L'.')
496 {
497 Dots = FALSE;
498 }
499
500 if (*c != '\\' && vfatIsLongIllegal(*c))
501 {
502 return(STATUS_OBJECT_NAME_INVALID);
503 }
504 }
505 if (FileObject->RelatedFileObject && PathNameU.Length >= sizeof(WCHAR) && PathNameU.Buffer[0] == L'\\')
506 {
507 return(STATUS_OBJECT_NAME_INVALID);
508 }
509 if (PathNameU.Length > sizeof(WCHAR) && PathNameU.Buffer[PathNameU.Length/sizeof(WCHAR)-1] == L'\\')
510 {
511 PathNameU.Length -= sizeof(WCHAR);
512 }
513
514 /* Try opening the file. */
515 Status = VfatOpenFile (DeviceExt, &PathNameU, FileObject, &ParentFcb);
516
517 /*
518 * If the directory containing the file to open doesn't exist then
519 * fail immediately
520 */
521 if (Status == STATUS_OBJECT_PATH_NOT_FOUND ||
522 Status == STATUS_INVALID_PARAMETER ||
523 Status == STATUS_DELETE_PENDING)
524 {
525 if (ParentFcb)
526 {
527 vfatReleaseFCB (DeviceExt, ParentFcb);
528 }
529 return(Status);
530 }
531 if (!NT_SUCCESS(Status) && ParentFcb == NULL)
532 {
533 DPRINT1("VfatOpenFile faild for '%wZ', status %x\n", &PathNameU, Status);
534 return Status;
535 }
536
537 /*
538 * If the file open failed then create the required file
539 */
540 if (!NT_SUCCESS (Status))
541 {
542 if (RequestedDisposition == FILE_CREATE ||
543 RequestedDisposition == FILE_OPEN_IF ||
544 RequestedDisposition == FILE_OVERWRITE_IF ||
545 RequestedDisposition == FILE_SUPERSEDE)
546 {
547 ULONG Attributes;
548 Attributes = Stack->Parameters.Create.FileAttributes & ~FILE_ATTRIBUTE_NORMAL;
549
550 vfatSplitPathName(&PathNameU, NULL, &FileNameU);
551 Status = VfatAddEntry (DeviceExt, &FileNameU, &pFcb, ParentFcb, RequestedOptions,
552 (UCHAR)(Attributes & FILE_ATTRIBUTE_VALID_FLAGS));
553 vfatReleaseFCB (DeviceExt, ParentFcb);
554 if (NT_SUCCESS (Status))
555 {
556 Status = vfatAttachFCBToFileObject (DeviceExt, pFcb, FileObject);
557 if ( !NT_SUCCESS(Status) )
558 {
559 vfatReleaseFCB (DeviceExt, pFcb);
560 return Status;
561 }
562
563 Irp->IoStatus.Information = FILE_CREATED;
564 VfatSetAllocationSizeInformation(FileObject,
565 pFcb,
566 DeviceExt,
567 &Irp->Overlay.AllocationSize);
568 VfatSetExtendedAttributes(FileObject,
569 Irp->AssociatedIrp.SystemBuffer,
570 Stack->Parameters.Create.EaLength);
571
572 if (PagingFileCreate)
573 {
574 pFcb->Flags |= FCB_IS_PAGE_FILE;
575 }
576 }
577 else
578 {
579 return(Status);
580 }
581 }
582 else
583 {
584 if (ParentFcb)
585 {
586 vfatReleaseFCB (DeviceExt, ParentFcb);
587 }
588 return(Status);
589 }
590 }
591 else
592 {
593 if (ParentFcb)
594 {
595 vfatReleaseFCB (DeviceExt, ParentFcb);
596 }
597 /* Otherwise fail if the caller wanted to create a new file */
598 if (RequestedDisposition == FILE_CREATE)
599 {
600 Irp->IoStatus.Information = FILE_EXISTS;
601 VfatCloseFile (DeviceExt, FileObject);
602 return(STATUS_OBJECT_NAME_COLLISION);
603 }
604
605 pFcb = FileObject->FsContext;
606
607 if (pFcb->OpenHandleCount != 0)
608 {
609 Status = IoCheckShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
610 Stack->Parameters.Create.ShareAccess,
611 FileObject,
612 &pFcb->FCBShareAccess,
613 FALSE);
614 if (!NT_SUCCESS(Status))
615 {
616 VfatCloseFile (DeviceExt, FileObject);
617 return(Status);
618 }
619 }
620
621 /*
622 * Check the file has the requested attributes
623 */
624 if (RequestedOptions & FILE_NON_DIRECTORY_FILE &&
625 *pFcb->Attributes & FILE_ATTRIBUTE_DIRECTORY)
626 {
627 VfatCloseFile (DeviceExt, FileObject);
628 return(STATUS_FILE_IS_A_DIRECTORY);
629 }
630 if (RequestedOptions & FILE_DIRECTORY_FILE &&
631 !(*pFcb->Attributes & FILE_ATTRIBUTE_DIRECTORY))
632 {
633 VfatCloseFile (DeviceExt, FileObject);
634 return(STATUS_NOT_A_DIRECTORY);
635 }
636 #ifndef USE_ROS_CC_AND_FS
637 if (!(*pFcb->Attributes & FILE_ATTRIBUTE_DIRECTORY))
638 {
639 if (Stack->Parameters.Create.SecurityContext->DesiredAccess & FILE_WRITE_DATA ||
640 RequestedDisposition == FILE_OVERWRITE ||
641 RequestedDisposition == FILE_OVERWRITE_IF)
642 {
643 if (!MmFlushImageSection(&pFcb->SectionObjectPointers, MmFlushForWrite))
644 {
645 DPRINT1("%wZ\n", &pFcb->PathNameU);
646 DPRINT1("%d %d %d\n", Stack->Parameters.Create.SecurityContext->DesiredAccess & FILE_WRITE_DATA,
647 RequestedDisposition == FILE_OVERWRITE, RequestedDisposition == FILE_OVERWRITE_IF);
648 VfatCloseFile (DeviceExt, FileObject);
649 return STATUS_SHARING_VIOLATION;
650 }
651 }
652 }
653 #endif
654 if (PagingFileCreate)
655 {
656 /* FIXME:
657 * Do more checking for page files. It is possible,
658 * that the file was opened and closed previously
659 * as a normal cached file. In this case, the cache
660 * manager has referenced the fileobject and the fcb
661 * is held in memory. Try to remove the fileobject
662 * from cache manager and use the fcb.
663 */
664 if (pFcb->RefCount > 1)
665 {
666 if(!(pFcb->Flags & FCB_IS_PAGE_FILE))
667 {
668 VfatCloseFile(DeviceExt, FileObject);
669 return(STATUS_INVALID_PARAMETER);
670 }
671 }
672 else
673 {
674 pFcb->Flags |= FCB_IS_PAGE_FILE;
675 }
676 }
677 else
678 {
679 if (pFcb->Flags & FCB_IS_PAGE_FILE)
680 {
681 VfatCloseFile(DeviceExt, FileObject);
682 return(STATUS_INVALID_PARAMETER);
683 }
684 }
685
686
687 if (RequestedDisposition == FILE_OVERWRITE ||
688 RequestedDisposition == FILE_OVERWRITE_IF ||
689 RequestedDisposition == FILE_SUPERSEDE)
690 {
691 ExAcquireResourceExclusiveLite(&(pFcb->MainResource), TRUE);
692 Status = VfatSetAllocationSizeInformation (FileObject,
693 pFcb,
694 DeviceExt,
695 &Irp->Overlay.AllocationSize);
696 ExReleaseResourceLite(&(pFcb->MainResource));
697 if (!NT_SUCCESS (Status))
698 {
699 VfatCloseFile (DeviceExt, FileObject);
700 return(Status);
701 }
702 }
703
704 if (RequestedDisposition == FILE_SUPERSEDE)
705 {
706 Irp->IoStatus.Information = FILE_SUPERSEDED;
707 }
708 else if (RequestedDisposition == FILE_OVERWRITE ||
709 RequestedDisposition == FILE_OVERWRITE_IF)
710 {
711 Irp->IoStatus.Information = FILE_OVERWRITTEN;
712 }
713 else
714 {
715 Irp->IoStatus.Information = FILE_OPENED;
716 }
717 }
718
719 if (pFcb->OpenHandleCount == 0)
720 {
721 IoSetShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
722 Stack->Parameters.Create.ShareAccess,
723 FileObject,
724 &pFcb->FCBShareAccess);
725 }
726 else
727 {
728 IoUpdateShareAccess(
729 FileObject,
730 &pFcb->FCBShareAccess
731 );
732
733 }
734
735 pFcb->OpenHandleCount++;
736
737 /* FIXME : test write access if requested */
738
739 return(Status);
740 }
741
742
743 NTSTATUS
744 VfatCreate (PVFAT_IRP_CONTEXT IrpContext)
745 /*
746 * FUNCTION: Create or open a file
747 */
748 {
749 NTSTATUS Status;
750
751 ASSERT(IrpContext);
752
753 if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
754 {
755 /* DeviceObject represents FileSystem instead of logical volume */
756 DPRINT ("FsdCreate called with file system\n");
757 IrpContext->Irp->IoStatus.Information = FILE_OPENED;
758 IrpContext->Irp->IoStatus.Status = STATUS_SUCCESS;
759 IoCompleteRequest (IrpContext->Irp, IO_DISK_INCREMENT);
760 VfatFreeIrpContext(IrpContext);
761 return(STATUS_SUCCESS);
762 }
763
764 if (!(IrpContext->Flags & IRPCONTEXT_CANWAIT))
765 {
766 return(VfatQueueRequest (IrpContext));
767 }
768
769 IrpContext->Irp->IoStatus.Information = 0;
770 ExAcquireResourceExclusiveLite (&IrpContext->DeviceExt->DirResource, TRUE);
771 Status = VfatCreateFile (IrpContext->DeviceObject, IrpContext->Irp);
772 ExReleaseResourceLite (&IrpContext->DeviceExt->DirResource);
773
774 IrpContext->Irp->IoStatus.Status = Status;
775 IoCompleteRequest (IrpContext->Irp,
776 (CCHAR)(NT_SUCCESS(Status) ? IO_DISK_INCREMENT : IO_NO_INCREMENT));
777 VfatFreeIrpContext(IrpContext);
778 return(Status);
779 }
780
781 /* EOF */
A free Windows-compatible Operating System