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