projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[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/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 (Status == STATUS_VERIFY_REQUIRED)
376
377 {
378 PDEVICE_OBJECT DeviceToVerify;
379
380 DPRINT ("Media change detected!\n");
381 DPRINT ("Device %p\n", DeviceExt->StorageDevice);
382
383 /* Find the device to verify and reset the thread field to empty value again. */
384 DeviceToVerify = IoGetDeviceToVerify (PsGetCurrentThread ());
385 IoSetDeviceToVerify (PsGetCurrentThread (), NULL);
386 Status = IoVerifyVolume (DeviceToVerify,
387 FALSE);
388 }
389 if (!NT_SUCCESS(Status))
390 {
391 DPRINT ("Status %lx\n", Status);
392 *ParentFcb = NULL;
393 return Status;
394 }
395 }
396
397 if (*ParentFcb)
398 {
399 (*ParentFcb)->RefCount++;
400 }
401
402 /* try first to find an existing FCB in memory */
403 DPRINT ("Checking for existing FCB in memory\n");
404
405 Status = vfatGetFCBForFile (DeviceExt, ParentFcb, &Fcb, PathNameU);
406 if (!NT_SUCCESS (Status))
407 {
408 DPRINT ("Could not make a new FCB, status: %x\n", Status);
409 return Status;
410 }
411 if (Fcb->Flags & FCB_DELETE_PENDING)
412 {
413 vfatReleaseFCB (DeviceExt, Fcb);
414 return STATUS_DELETE_PENDING;
415 }
416 DPRINT ("Attaching FCB to fileObject\n");
417 Status = vfatAttachFCBToFileObject (DeviceExt, Fcb, FileObject);
418 if (!NT_SUCCESS(Status))
419 {
420 vfatReleaseFCB (DeviceExt, Fcb);
421 }
422 return Status;
423 }
424
425 static NTSTATUS
426 VfatCreateFile ( PDEVICE_OBJECT DeviceObject, PIRP Irp )
427 /*
428 * FUNCTION: Create or open a file
429 */
430 {
431 PIO_STACK_LOCATION Stack;
432 PFILE_OBJECT FileObject;
433 NTSTATUS Status = STATUS_SUCCESS;
434 PDEVICE_EXTENSION DeviceExt;
435 ULONG RequestedDisposition, RequestedOptions;
436 PVFATFCB pFcb = NULL;
437 PVFATFCB ParentFcb = NULL;
438 PWCHAR c, last;
439 BOOLEAN PagingFileCreate = FALSE;
440 BOOLEAN Dots;
441 UNICODE_STRING FileNameU;
442 UNICODE_STRING PathNameU;
443
444 /* Unpack the various parameters. */
445 Stack = IoGetCurrentIrpStackLocation (Irp);
446 RequestedDisposition = ((Stack->Parameters.Create.Options >> 24) & 0xff);
447 RequestedOptions =
448 Stack->Parameters.Create.Options & FILE_VALID_OPTION_FLAGS;
449 PagingFileCreate = (Stack->Flags & SL_OPEN_PAGING_FILE) ? TRUE : FALSE;
450 FileObject = Stack->FileObject;
451 DeviceExt = DeviceObject->DeviceExtension;
452
453 /* Check their validity. */
454 if (RequestedOptions & FILE_DIRECTORY_FILE &&
455 RequestedDisposition == FILE_SUPERSEDE)
456 {
457 return(STATUS_INVALID_PARAMETER);
458 }
459
460 if (RequestedOptions & FILE_DIRECTORY_FILE &&
461 RequestedOptions & FILE_NON_DIRECTORY_FILE)
462 {
463 return(STATUS_INVALID_PARAMETER);
464 }
465
466 /* This a open operation for the volume itself */
467 if (FileObject->FileName.Length == 0 &&
468 (FileObject->RelatedFileObject == NULL || FileObject->RelatedFileObject->FsContext2 != NULL))
469 {
470 if (RequestedDisposition != FILE_OPEN ||
471 RequestedDisposition != FILE_OPEN_IF)
472 {
473 return(STATUS_ACCESS_DENIED);
474 }
475 #if 0
476 /* In spite of what is shown in WDK, it seems that Windows FAT driver doesn't perform that test */
477 if (RequestedOptions & FILE_DIRECTORY_FILE)
478 {
479 return(STATUS_NOT_A_DIRECTORY);
480 }
481 #endif
482
483 pFcb = DeviceExt->VolumeFcb;
484 vfatAttachFCBToFileObject(DeviceExt, pFcb, FileObject);
485 pFcb->RefCount++;
486
487 Irp->IoStatus.Information = FILE_OPENED;
488 return(STATUS_SUCCESS);
489 }
490
491 /*
492 * Check for illegal characters and illegale dot sequences in the file name
493 */
494 PathNameU = FileObject->FileName;
495 c = PathNameU.Buffer + PathNameU.Length / sizeof(WCHAR);
496 last = c - 1;
497 Dots = TRUE;
498 while (c-- > PathNameU.Buffer)
499 {
500 if (*c == L'\\' || c == PathNameU.Buffer)
501 {
502 if (Dots && last > c)
503 {
504 return(STATUS_OBJECT_NAME_INVALID);
505 }
506 last = c - 1;
507 Dots = TRUE;
508 }
509 else if (*c != L'.')
510 {
511 Dots = FALSE;
512 }
513
514 if (*c != '\\' && vfatIsLongIllegal(*c))
515 {
516 return(STATUS_OBJECT_NAME_INVALID);
517 }
518 }
519 if (FileObject->RelatedFileObject && PathNameU.Length >= sizeof(WCHAR) && PathNameU.Buffer[0] == L'\\')
520 {
521 return(STATUS_OBJECT_NAME_INVALID);
522 }
523 if (PathNameU.Length > sizeof(WCHAR) && PathNameU.Buffer[PathNameU.Length/sizeof(WCHAR)-1] == L'\\')
524 {
525 PathNameU.Length -= sizeof(WCHAR);
526 }
527
528 /* Try opening the file. */
529 Status = VfatOpenFile (DeviceExt, &PathNameU, FileObject, &ParentFcb);
530
531 /*
532 * If the directory containing the file to open doesn't exist then
533 * fail immediately
534 */
535 if (Status == STATUS_OBJECT_PATH_NOT_FOUND ||
536 Status == STATUS_INVALID_PARAMETER ||
537 Status == STATUS_DELETE_PENDING)
538 {
539 if (ParentFcb)
540 {
541 vfatReleaseFCB (DeviceExt, ParentFcb);
542 }
543 return(Status);
544 }
545 if (!NT_SUCCESS(Status) && ParentFcb == NULL)
546 {
547 DPRINT1("VfatOpenFile faild for '%wZ', status %x\n", &PathNameU, Status);
548 return Status;
549 }
550
551 /*
552 * If the file open failed then create the required file
553 */
554 if (!NT_SUCCESS (Status))
555 {
556 if (RequestedDisposition == FILE_CREATE ||
557 RequestedDisposition == FILE_OPEN_IF ||
558 RequestedDisposition == FILE_OVERWRITE_IF ||
559 RequestedDisposition == FILE_SUPERSEDE)
560 {
561 ULONG Attributes;
562 Attributes = Stack->Parameters.Create.FileAttributes;
563
564 vfatSplitPathName(&PathNameU, NULL, &FileNameU);
565 Status = VfatAddEntry (DeviceExt, &FileNameU, &pFcb, ParentFcb, RequestedOptions,
566 (UCHAR)(Attributes & FILE_ATTRIBUTE_VALID_FLAGS));
567 vfatReleaseFCB (DeviceExt, ParentFcb);
568 if (NT_SUCCESS (Status))
569 {
570 Status = vfatAttachFCBToFileObject (DeviceExt, pFcb, FileObject);
571 if ( !NT_SUCCESS(Status) )
572 {
573 vfatReleaseFCB (DeviceExt, pFcb);
574 return Status;
575 }
576
577 Irp->IoStatus.Information = FILE_CREATED;
578 VfatSetAllocationSizeInformation(FileObject,
579 pFcb,
580 DeviceExt,
581 &Irp->Overlay.AllocationSize);
582 VfatSetExtendedAttributes(FileObject,
583 Irp->AssociatedIrp.SystemBuffer,
584 Stack->Parameters.Create.EaLength);
585
586 if (PagingFileCreate)
587 {
588 pFcb->Flags |= FCB_IS_PAGE_FILE;
589 }
590 }
591 else
592 {
593 return(Status);
594 }
595 }
596 else
597 {
598 if (ParentFcb)
599 {
600 vfatReleaseFCB (DeviceExt, ParentFcb);
601 }
602 return(Status);
603 }
604 }
605 else
606 {
607 if (ParentFcb)
608 {
609 vfatReleaseFCB (DeviceExt, ParentFcb);
610 }
611 /* Otherwise fail if the caller wanted to create a new file */
612 if (RequestedDisposition == FILE_CREATE)
613 {
614 Irp->IoStatus.Information = FILE_EXISTS;
615 VfatCloseFile (DeviceExt, FileObject);
616 return(STATUS_OBJECT_NAME_COLLISION);
617 }
618
619 pFcb = FileObject->FsContext;
620
621 if (pFcb->OpenHandleCount != 0)
622 {
623 Status = IoCheckShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
624 Stack->Parameters.Create.ShareAccess,
625 FileObject,
626 &pFcb->FCBShareAccess,
627 FALSE);
628 if (!NT_SUCCESS(Status))
629 {
630 VfatCloseFile (DeviceExt, FileObject);
631 return(Status);
632 }
633 }
634
635 /*
636 * Check the file has the requested attributes
637 */
638 if (RequestedOptions & FILE_NON_DIRECTORY_FILE &&
639 *pFcb->Attributes & FILE_ATTRIBUTE_DIRECTORY)
640 {
641 VfatCloseFile (DeviceExt, FileObject);
642 return(STATUS_FILE_IS_A_DIRECTORY);
643 }
644 if (RequestedOptions & FILE_DIRECTORY_FILE &&
645 !(*pFcb->Attributes & FILE_ATTRIBUTE_DIRECTORY))
646 {
647 VfatCloseFile (DeviceExt, FileObject);
648 return(STATUS_NOT_A_DIRECTORY);
649 }
650 #ifndef USE_ROS_CC_AND_FS
651 if (!(*pFcb->Attributes & FILE_ATTRIBUTE_DIRECTORY))
652 {
653 if (Stack->Parameters.Create.SecurityContext->DesiredAccess & FILE_WRITE_DATA ||
654 RequestedDisposition == FILE_OVERWRITE ||
655 RequestedDisposition == FILE_OVERWRITE_IF)
656 {
657 if (!MmFlushImageSection(&pFcb->SectionObjectPointers, MmFlushForWrite))
658 {
659 DPRINT1("%wZ\n", &pFcb->PathNameU);
660 DPRINT1("%d %d %d\n", Stack->Parameters.Create.SecurityContext->DesiredAccess & FILE_WRITE_DATA,
661 RequestedDisposition == FILE_OVERWRITE, RequestedDisposition == FILE_OVERWRITE_IF);
662 VfatCloseFile (DeviceExt, FileObject);
663 return STATUS_SHARING_VIOLATION;
664 }
665 }
666 }
667 #endif
668 if (PagingFileCreate)
669 {
670 /* FIXME:
671 * Do more checking for page files. It is possible,
672 * that the file was opened and closed previously
673 * as a normal cached file. In this case, the cache
674 * manager has referenced the fileobject and the fcb
675 * is held in memory. Try to remove the fileobject
676 * from cache manager and use the fcb.
677 */
678 if (pFcb->RefCount > 1)
679 {
680 if(!(pFcb->Flags & FCB_IS_PAGE_FILE))
681 {
682 VfatCloseFile(DeviceExt, FileObject);
683 return(STATUS_INVALID_PARAMETER);
684 }
685 }
686 else
687 {
688 pFcb->Flags |= FCB_IS_PAGE_FILE;
689 }
690 }
691 else
692 {
693 if (pFcb->Flags & FCB_IS_PAGE_FILE)
694 {
695 VfatCloseFile(DeviceExt, FileObject);
696 return(STATUS_INVALID_PARAMETER);
697 }
698 }
699
700
701 if (RequestedDisposition == FILE_OVERWRITE ||
702 RequestedDisposition == FILE_OVERWRITE_IF ||
703 RequestedDisposition == FILE_SUPERSEDE)
704 {
705 ExAcquireResourceExclusiveLite(&(pFcb->MainResource), TRUE);
706 Status = VfatSetAllocationSizeInformation (FileObject,
707 pFcb,
708 DeviceExt,
709 &Irp->Overlay.AllocationSize);
710 ExReleaseResourceLite(&(pFcb->MainResource));
711 if (!NT_SUCCESS (Status))
712 {
713 VfatCloseFile (DeviceExt, FileObject);
714 return(Status);
715 }
716 }
717
718 if (RequestedDisposition == FILE_SUPERSEDE)
719 {
720 Irp->IoStatus.Information = FILE_SUPERSEDED;
721 }
722 else if (RequestedDisposition == FILE_OVERWRITE ||
723 RequestedDisposition == FILE_OVERWRITE_IF)
724 {
725 Irp->IoStatus.Information = FILE_OVERWRITTEN;
726 }
727 else
728 {
729 Irp->IoStatus.Information = FILE_OPENED;
730 }
731 }
732
733 if (pFcb->OpenHandleCount == 0)
734 {
735 IoSetShareAccess(Stack->Parameters.Create.SecurityContext->DesiredAccess,
736 Stack->Parameters.Create.ShareAccess,
737 FileObject,
738 &pFcb->FCBShareAccess);
739 }
740 else
741 {
742 IoUpdateShareAccess(
743 FileObject,
744 &pFcb->FCBShareAccess
745 );
746
747 }
748
749 pFcb->OpenHandleCount++;
750
751 /* FIXME : test write access if requested */
752
753 return(Status);
754 }
755
756
757 NTSTATUS
758 VfatCreate (PVFAT_IRP_CONTEXT IrpContext)
759 /*
760 * FUNCTION: Create or open a file
761 */
762 {
763 NTSTATUS Status;
764
765 ASSERT(IrpContext);
766
767 if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
768 {
769 /* DeviceObject represents FileSystem instead of logical volume */
770 DPRINT ("FsdCreate called with file system\n");
771 IrpContext->Irp->IoStatus.Information = FILE_OPENED;
772 IrpContext->Irp->IoStatus.Status = STATUS_SUCCESS;
773 IoCompleteRequest (IrpContext->Irp, IO_DISK_INCREMENT);
774 VfatFreeIrpContext(IrpContext);
775 return(STATUS_SUCCESS);
776 }
777
778 if (!(IrpContext->Flags & IRPCONTEXT_CANWAIT))
779 {
780 return(VfatQueueRequest (IrpContext));
781 }
782
783 IrpContext->Irp->IoStatus.Information = 0;
784 ExAcquireResourceExclusiveLite (&IrpContext->DeviceExt->DirResource, TRUE);
785 Status = VfatCreateFile (IrpContext->DeviceObject, IrpContext->Irp);
786 ExReleaseResourceLite (&IrpContext->DeviceExt->DirResource);
787
788 IrpContext->Irp->IoStatus.Status = Status;
789 IoCompleteRequest (IrpContext->Irp,
790 (CCHAR)(NT_SUCCESS(Status) ? IO_DISK_INCREMENT : IO_NO_INCREMENT));
791 VfatFreeIrpContext(IrpContext);
792 return(Status);
793 }
794
795 /* EOF */
A free Windows-compatible Operating System