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