reactos/drivers/filesystems/fastfat_new/create.c

/*
 * PROJECT:         ReactOS FAT file system driver
 * LICENSE:         GNU GPLv3 as published by the Free Software Foundation
 * FILE:            drivers/filesystems/fastfat/create.c
 * PURPOSE:         Create routines
 * PROGRAMMERS:     Aleksey Bragin (aleksey@reactos.org)
 */

/* INCLUDES *****************************************************************/

#define NDEBUG
#include "fastfat.h"

/* FUNCTIONS *****************************************************************/

IO_STATUS_BLOCK
NTAPI
FatiOpenRootDcb(IN PFAT_IRP_CONTEXT IrpContext,
                IN PFILE_OBJECT FileObject,
                IN PVCB Vcb,
                IN PACCESS_MASK DesiredAccess,
                IN USHORT ShareAccess,
                IN ULONG CreateDisposition)
{
    IO_STATUS_BLOCK Iosb;
    PFCB Dcb;
    NTSTATUS Status;
    PCCB Ccb;

    /* Reference our DCB */
    Dcb = Vcb->RootDcb;

    DPRINT("Opening root directory\n");

    /* Exclusively lock this DCB */
    (VOID)FatAcquireExclusiveFcb(IrpContext, Dcb);

    do
    {
        /* Validate parameters */
        if (CreateDisposition != FILE_OPEN &&
            CreateDisposition != FILE_OPEN_IF)
        {
            Iosb.Status = STATUS_ACCESS_DENIED;
            break;
        }

        // TODO: Check file access

        /* Is it a first time open? */
        if (Dcb->OpenCount == 0)
        {
            /* Set share access */
            IoSetShareAccess(*DesiredAccess,
                             ShareAccess,
                             FileObject,
                             &Dcb->ShareAccess);
        }
        else
        {
            /* Check share access */
            Status = IoCheckShareAccess(*DesiredAccess,
                                        ShareAccess,
                                        FileObject,
                                        &Dcb->ShareAccess,
                                        TRUE);
        }

        /* Set file object pointers */
        Ccb = FatCreateCcb();
        FatSetFileObject(FileObject, UserDirectoryOpen, Dcb, Ccb);

        /* Increment counters */
        Dcb->OpenCount++;
        Dcb->UncleanCount++;
        Vcb->OpenFileCount++;
        if (IsFileObjectReadOnly(FileObject)) Vcb->ReadOnlyCount++;

        /* Set success statuses */
        Iosb.Status = STATUS_SUCCESS;
        Iosb.Information = FILE_OPENED;
    } while (FALSE);

    /* Release the DCB lock */
    FatReleaseFcb(IrpContext, Dcb);

    return Iosb;
}

FF_ERROR
NTAPI
FatiTryToOpen(IN PFILE_OBJECT FileObject,
              IN PVCB Vcb)
{
    OEM_STRING AnsiName;
    CHAR AnsiNameBuf[512];
    FF_ERROR Error;
    NTSTATUS Status;
    FF_FILE *FileHandle;

    /* Convert the name to ANSI */
    AnsiName.Buffer = AnsiNameBuf;
    AnsiName.Length = 0;
    AnsiName.MaximumLength = sizeof(AnsiNameBuf);
    RtlZeroMemory(AnsiNameBuf, sizeof(AnsiNameBuf));
    Status = RtlUpcaseUnicodeStringToCountedOemString(&AnsiName, &FileObject->FileName, FALSE);
    if (!NT_SUCCESS(Status))
    {
        ASSERT(FALSE);
    }

    /* Open the file with FullFAT */
    FileHandle = FF_Open(Vcb->Ioman, AnsiName.Buffer, FF_MODE_READ, &Error);

    /* Close the handle */
    if (FileHandle) FF_Close(FileHandle);

    /* Return status */
    return Error;
}

IO_STATUS_BLOCK
NTAPI
FatiOverwriteFile(PFAT_IRP_CONTEXT IrpContext,
                  PFILE_OBJECT FileObject,
                  PFCB Fcb,
                  ULONG AllocationSize,
                  PFILE_FULL_EA_INFORMATION EaBuffer,
                  ULONG EaLength,
                  UCHAR FileAttributes,
                  ULONG CreateDisposition,
                  BOOLEAN NoEaKnowledge)
{
    IO_STATUS_BLOCK Iosb = {{0}};
    PCCB Ccb;
    LARGE_INTEGER Zero;
    ULONG NotifyFilter;

    Zero.QuadPart = 0;

    /* Check Ea mismatch first */
    if (NoEaKnowledge && EaLength > 0)
    {
        Iosb.Status = STATUS_ACCESS_DENIED;
        return Iosb;
    }

    do
    {
        /* Check if it's not still mapped */
        if (!MmCanFileBeTruncated(&Fcb->SectionObjectPointers,
                                  &Zero))
        {
            /* Fail */
            Iosb.Status = STATUS_USER_MAPPED_FILE;
            break;
        }

        /* Set file object pointers */
        Ccb = FatCreateCcb();
        FatSetFileObject(FileObject,
                         UserFileOpen,
                         Fcb,
                         Ccb);

        FileObject->SectionObjectPointer = &Fcb->SectionObjectPointers;

        /* Indicate that create is in progress */
        Fcb->Vcb->State |= VCB_STATE_CREATE_IN_PROGRESS;

        /* Purge the cache section */
        CcPurgeCacheSection(&Fcb->SectionObjectPointers, NULL, 0, FALSE);

        /* Add Eas */
        if (EaLength > 0)
        {
            ASSERT(FALSE);
        }

        /* Acquire the paging resource */
        (VOID)ExAcquireResourceExclusiveLite(Fcb->Header.PagingIoResource, TRUE);

        /* Initialize FCB header */
        Fcb->Header.FileSize.QuadPart = 0;
        Fcb->Header.ValidDataLength.QuadPart = 0;

        /* Let CC know about changed file size */
        CcSetFileSizes(FileObject, (PCC_FILE_SIZES)&Fcb->Header.AllocationSize);

        // TODO: Actually truncate the file
        DPRINT1("TODO: Actually truncate file '%wZ' with a fullfat handle %x\n", &Fcb->FullFileName, Fcb->FatHandle);

        /* Release the paging resource */
        ExReleaseResourceLite(Fcb->Header.PagingIoResource);

        /* Specify truncate on close */
        Fcb->State |= FCB_STATE_TRUNCATE_ON_CLOSE;

        // TODO: Delete previous EA if needed

        /* Send notification about changes */
        NotifyFilter = FILE_NOTIFY_CHANGE_LAST_WRITE |
                       FILE_NOTIFY_CHANGE_ATTRIBUTES |
                       FILE_NOTIFY_CHANGE_SIZE;

        FsRtlNotifyFullReportChange(Fcb->Vcb->NotifySync,
                                    &Fcb->Vcb->NotifyList,
                                    (PSTRING)&Fcb->FullFileName,
                                    Fcb->FullFileName.Length - Fcb->FileNameLength,
                                    NULL,
                                    NULL,
                                    NotifyFilter,
                                    FILE_ACTION_MODIFIED,
                                    NULL);

        /* Set success status */
        Iosb.Status = STATUS_SUCCESS;

        /* Set correct information code */
        Iosb.Information = (CreateDisposition == FILE_SUPERSEDE) ? FILE_SUPERSEDED : FILE_OVERWRITTEN;
    } while (0);

    /* Remove the create in progress flag */
    ClearFlag(Fcb->Vcb->State, VCB_STATE_CREATE_IN_PROGRESS);

    return Iosb;
}

IO_STATUS_BLOCK
NTAPI
FatiOpenExistingDir(IN PFAT_IRP_CONTEXT IrpContext,
                     IN PFILE_OBJECT FileObject,
                     IN PVCB Vcb,
                     IN PFCB ParentDcb,
                     IN PACCESS_MASK DesiredAccess,
                     IN USHORT ShareAccess,
                     IN ULONG AllocationSize,
                     IN PFILE_FULL_EA_INFORMATION EaBuffer,
                     IN ULONG EaLength,
                     IN UCHAR FileAttributes,
                     IN ULONG CreateDisposition,
                     IN BOOLEAN DeleteOnClose)
{
    IO_STATUS_BLOCK Iosb = {{0}};
    OEM_STRING AnsiName;
    CHAR AnsiNameBuf[512];
    PFCB Fcb;
    NTSTATUS Status;
    FF_FILE *FileHandle;

    /* Only open is permitted */
    if (CreateDisposition != FILE_OPEN &&
        CreateDisposition != FILE_OPEN_IF)
    {
        Iosb.Status = STATUS_OBJECT_NAME_COLLISION;
        return Iosb;
    }

    // TODO: Check dir access

    /* Convert the name to ANSI */
    AnsiName.Buffer = AnsiNameBuf;
    AnsiName.Length = 0;
    AnsiName.MaximumLength = sizeof(AnsiNameBuf);
    RtlZeroMemory(AnsiNameBuf, sizeof(AnsiNameBuf));
    Status = RtlUpcaseUnicodeStringToCountedOemString(&AnsiName, &FileObject->FileName, FALSE);
    if (!NT_SUCCESS(Status))
    {
        ASSERT(FALSE);
    }

    /* Open the dir with FullFAT */
    FileHandle = FF_Open(Vcb->Ioman, AnsiName.Buffer, FF_MODE_DIR, NULL);

    if (!FileHandle)
    {
        Iosb.Status = STATUS_OBJECT_NAME_NOT_FOUND; // FIXME: A shortcut for now
        return Iosb;
    }

    /* Create a new DCB for this directory */
    Fcb = FatCreateDcb(IrpContext, Vcb, ParentDcb, FileHandle);

    /* Set share access */
    IoSetShareAccess(*DesiredAccess, ShareAccess, FileObject, &Fcb->ShareAccess);

    /* Set context and section object pointers */
    FatSetFileObject(FileObject,
                     UserDirectoryOpen,
                     Fcb,
                     FatCreateCcb());

    /* Increase counters */
    Fcb->UncleanCount++;
    Fcb->OpenCount++;
    Vcb->OpenFileCount++;
    if (IsFileObjectReadOnly(FileObject)) Vcb->ReadOnlyCount++;

    Iosb.Status = STATUS_SUCCESS;
    Iosb.Information = FILE_OPENED;

    DPRINT1("Successfully opened dir %s\n", AnsiNameBuf);

    return Iosb;
}

IO_STATUS_BLOCK
NTAPI
FatiOpenExistingFile(IN PFAT_IRP_CONTEXT IrpContext,
                     IN PFILE_OBJECT FileObject,
                     IN PVCB Vcb,
                     IN PFCB ParentDcb,
                     IN PACCESS_MASK DesiredAccess,
                     IN USHORT ShareAccess,
                     IN ULONG AllocationSize,
                     IN PFILE_FULL_EA_INFORMATION EaBuffer,
                     IN ULONG EaLength,
                     IN UCHAR FileAttributes,
                     IN ULONG CreateDisposition,
                     IN BOOLEAN IsPagingFile,
                     IN BOOLEAN DeleteOnClose,
                     IN BOOLEAN IsDosName)
{
    IO_STATUS_BLOCK Iosb = {{0}};
    OEM_STRING AnsiName;
    CHAR AnsiNameBuf[512];
    PFCB Fcb;
    NTSTATUS Status;
    FF_FILE *FileHandle;
    FF_ERROR FfError;

    /* Check for create file option and fail */
    if (CreateDisposition == FILE_CREATE)
    {
        Iosb.Status = STATUS_OBJECT_NAME_COLLISION;
        return Iosb;
    }

    // TODO: Check more params

    /* Convert the name to ANSI */
    AnsiName.Buffer = AnsiNameBuf;
    AnsiName.Length = 0;
    AnsiName.MaximumLength = sizeof(AnsiNameBuf);
    RtlZeroMemory(AnsiNameBuf, sizeof(AnsiNameBuf));
    Status = RtlUpcaseUnicodeStringToCountedOemString(&AnsiName, &FileObject->FileName, FALSE);
    if (!NT_SUCCESS(Status))
    {
        ASSERT(FALSE);
    }

    /* Open the file with FullFAT */
    FileHandle = FF_Open(Vcb->Ioman, AnsiName.Buffer, FF_MODE_READ, &FfError);

    if (!FileHandle)
    {
        DPRINT1("Failed to open file '%s', error %ld\n", AnsiName.Buffer, FfError);
        Iosb.Status = STATUS_OBJECT_NAME_NOT_FOUND; // FIXME: A shortcut for now
        return Iosb;
    }
    DPRINT1("Succeeded opening file '%s'\n", AnsiName.Buffer);

    /* Create a new FCB for this file */
    Fcb = FatCreateFcb(IrpContext, Vcb, ParentDcb, FileHandle);

    // TODO: Check if overwrite is needed

    // TODO: This is usual file open branch, without overwriting!
    /* Set context and section object pointers */
    FatSetFileObject(FileObject,
                     UserFileOpen,
                     Fcb,
                     FatCreateCcb());
    FileObject->SectionObjectPointer = &Fcb->SectionObjectPointers;

    Iosb.Status = STATUS_SUCCESS;
    Iosb.Information = FILE_OPENED;


    /* Increase counters */
    Fcb->UncleanCount++;
    Fcb->OpenCount++;
    if (FlagOn(FileObject->Flags, FO_NO_INTERMEDIATE_BUFFERING)) Fcb->NonCachedUncleanCount++;
    if (IsFileObjectReadOnly(FileObject)) Vcb->ReadOnlyCount++;

    return Iosb;
}

IO_STATUS_BLOCK
NTAPI
FatiOpenVolume(IN PFAT_IRP_CONTEXT IrpContext,
               IN PFILE_OBJECT FileObject,
               IN PVCB Vcb,
               IN PACCESS_MASK DesiredAccess,
               IN USHORT ShareAccess,
               IN ULONG CreateDisposition)
{
    PCCB Ccb;
    IO_STATUS_BLOCK Iosb = {{0}};
    BOOLEAN VolumeFlushed = FALSE;

    /* Check parameters */
    if (CreateDisposition != FILE_OPEN &&
        CreateDisposition != FILE_OPEN_IF)
    {
        /* Deny access */
        Iosb.Status = STATUS_ACCESS_DENIED;
    }

    /* Check if it's exclusive open */
    if (!FlagOn(ShareAccess, FILE_SHARE_WRITE) &&
        !FlagOn(ShareAccess, FILE_SHARE_DELETE))
    {
        // TODO: Check if exclusive read access requested
        // and opened handles count is not 0
        //if (!FlagOn(ShareAccess, FILE_SHARE_READ)

        DPRINT1("Exclusive volume open\n");

        // TODO: Flush the volume
        VolumeFlushed = TRUE;
    }
    else if (FlagOn(*DesiredAccess, FILE_READ_DATA | FILE_WRITE_DATA | FILE_APPEND_DATA))
    {
        DPRINT1("Shared open\n");

        // TODO: Flush the volume
        VolumeFlushed = TRUE;
    }

    if (VolumeFlushed &&
        !FlagOn(Vcb->State, VCB_STATE_MOUNTED_DIRTY) &&
        FlagOn(Vcb->State, VCB_STATE_FLAG_DIRTY) &&
        CcIsThereDirtyData(Vcb->Vpb))
    {
        UNIMPLEMENTED;
    }

    /* Set share access */
    if (Vcb->DirectOpenCount > 0)
    {
        /* This volume has already been opened */
        Iosb.Status = IoCheckShareAccess(*DesiredAccess,
                                         ShareAccess,
                                         FileObject,
                                         &Vcb->ShareAccess,
                                         TRUE);

        if (!NT_SUCCESS(Iosb.Status))
        {
            ASSERT(FALSE);
        }
    }
    else
    {
        /* This is the first time open */
        IoSetShareAccess(*DesiredAccess,
                         ShareAccess,
                         FileObject,
                         &Vcb->ShareAccess);
    }

    /* Set file object pointers */
    Ccb = FatCreateCcb();
    FatSetFileObject(FileObject, UserVolumeOpen, Vcb, Ccb);
    FileObject->SectionObjectPointer = &Vcb->SectionObjectPointers;

    /* Increase direct open count */
    Vcb->DirectOpenCount++;
    Vcb->OpenFileCount++;
    if (IsFileObjectReadOnly(FileObject)) Vcb->ReadOnlyCount++;

    /* Set no buffering flag */
    FileObject->Flags |= FO_NO_INTERMEDIATE_BUFFERING;

    // TODO: User's access check

    Iosb.Status = STATUS_SUCCESS;
    Iosb.Information = FILE_OPENED;

    return Iosb;
}

NTSTATUS
NTAPI
FatiCreate(IN PFAT_IRP_CONTEXT IrpContext,
           IN PIRP Irp)
{
    /* Boolean options */
    BOOLEAN CreateDirectory;
    BOOLEAN SequentialOnly;
    BOOLEAN NoIntermediateBuffering;
    BOOLEAN OpenDirectory;
    BOOLEAN IsPagingFile;
    BOOLEAN OpenTargetDirectory;
    BOOLEAN IsDirectoryFile;
    BOOLEAN NonDirectoryFile;
    BOOLEAN NoEaKnowledge;
    BOOLEAN DeleteOnClose;
    BOOLEAN TemporaryFile;
    ULONG CreateDisposition;

    /* Control blocks */
    PVCB Vcb, DecodedVcb, RelatedVcb;
    PFCB Fcb, NextFcb, RelatedDcb;
    PCCB Ccb, RelatedCcb;
    PFCB ParentDcb;

    /* IRP data */
    PFILE_OBJECT FileObject;
    PFILE_OBJECT RelatedFO;
    UNICODE_STRING FileName;
    ULONG AllocationSize;
    PFILE_FULL_EA_INFORMATION EaBuffer;
    PACCESS_MASK DesiredAccess;
    ULONG Options;
    UCHAR FileAttributes;
    USHORT ShareAccess;
    ULONG EaLength;

    /* Misc */
    NTSTATUS Status;
    IO_STATUS_BLOCK Iosb;
    PIO_STACK_LOCATION IrpSp;
    BOOLEAN EndBackslash = FALSE, OpenedAsDos, FirstRun = TRUE;
    UNICODE_STRING RemainingPart, FirstName, NextName, FileNameUpcased;
    OEM_STRING AnsiFirstName;
    FF_ERROR FfError;
    TYPE_OF_OPEN TypeOfOpen;
    BOOLEAN OplockPostIrp = FALSE;

    Iosb.Status = STATUS_SUCCESS;

    /* Get current IRP stack location */
    IrpSp = IoGetCurrentIrpStackLocation(Irp);

    DPRINT("FatCommonCreate\n", 0 );
    DPRINT("Irp                       = %08lx\n",   Irp );
    DPRINT("\t->Flags                   = %08lx\n", Irp->Flags );
    DPRINT("\t->FileObject              = %08lx\n", IrpSp->FileObject );
    DPRINT("\t->RelatedFileObject       = %08lx\n", IrpSp->FileObject->RelatedFileObject );
    DPRINT("\t->FileName                = %wZ\n",   &IrpSp->FileObject->FileName );
    DPRINT("\t->AllocationSize.LowPart  = %08lx\n", Irp->Overlay.AllocationSize.LowPart );
    DPRINT("\t->AllocationSize.HighPart = %08lx\n", Irp->Overlay.AllocationSize.HighPart );
    DPRINT("\t->SystemBuffer            = %08lx\n", Irp->AssociatedIrp.SystemBuffer );
    DPRINT("\t->DesiredAccess           = %08lx\n", IrpSp->Parameters.Create.SecurityContext->DesiredAccess );
    DPRINT("\t->Options                 = %08lx\n", IrpSp->Parameters.Create.Options );
    DPRINT("\t->FileAttributes          = %04x\n",  IrpSp->Parameters.Create.FileAttributes );
    DPRINT("\t->ShareAccess             = %04x\n",  IrpSp->Parameters.Create.ShareAccess );
    DPRINT("\t->EaLength                = %08lx\n", IrpSp->Parameters.Create.EaLength );

    /* Apply a special hack for Win32, idea taken from FASTFAT reference driver from WDK */
    if ((IrpSp->FileObject->FileName.Length > sizeof(WCHAR)) &&
        (IrpSp->FileObject->FileName.Buffer[1] == L'\\') &&
        (IrpSp->FileObject->FileName.Buffer[0] == L'\\'))
    {
        /* Remove a leading slash */
        IrpSp->FileObject->FileName.Length -= sizeof(WCHAR);
        RtlMoveMemory(&IrpSp->FileObject->FileName.Buffer[0],
                      &IrpSp->FileObject->FileName.Buffer[1],
                      IrpSp->FileObject->FileName.Length );

        /* Check again: if there are still two leading slashes,
           exit with an error */
        if ((IrpSp->FileObject->FileName.Length > sizeof(WCHAR)) &&
            (IrpSp->FileObject->FileName.Buffer[1] == L'\\') &&
            (IrpSp->FileObject->FileName.Buffer[0] == L'\\'))
        {
            FatCompleteRequest( IrpContext, Irp, STATUS_OBJECT_NAME_INVALID );

            DPRINT1("FatiCreate: STATUS_OBJECT_NAME_INVALID\n");
            return STATUS_OBJECT_NAME_INVALID;
        }
    }

    /* Make sure we have SecurityContext */
    ASSERT(IrpSp->Parameters.Create.SecurityContext != NULL);

    /* Get necessary data out of IRP */
    FileObject     = IrpSp->FileObject;
    FileName       = FileObject->FileName;
    RelatedFO      = FileObject->RelatedFileObject;
    AllocationSize = Irp->Overlay.AllocationSize.LowPart;
    EaBuffer       = Irp->AssociatedIrp.SystemBuffer;
    DesiredAccess  = &IrpSp->Parameters.Create.SecurityContext->DesiredAccess;
    Options        = IrpSp->Parameters.Create.Options;
    FileAttributes = (UCHAR)(IrpSp->Parameters.Create.FileAttributes & ~FILE_ATTRIBUTE_NORMAL);
    ShareAccess    = IrpSp->Parameters.Create.ShareAccess;
    EaLength       = IrpSp->Parameters.Create.EaLength;

    /* Set VPB to related object's VPB if it exists */
    if (RelatedFO)
        FileObject->Vpb = RelatedFO->Vpb;

    /* Reject open by id */
    if (Options & FILE_OPEN_BY_FILE_ID)
    {
        FatCompleteRequest(IrpContext, Irp, STATUS_INVALID_PARAMETER);
        return STATUS_INVALID_PARAMETER;
    }

    /* Prepare file attributes mask */
    FileAttributes &= (FILE_ATTRIBUTE_READONLY |
                       FILE_ATTRIBUTE_HIDDEN   |
                       FILE_ATTRIBUTE_SYSTEM   |
                       FILE_ATTRIBUTE_ARCHIVE);

    /* Get the volume control object */
    Vcb = &((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->Vcb;

    /* Get options */
    IsDirectoryFile         = BooleanFlagOn(Options, FILE_DIRECTORY_FILE);
    NonDirectoryFile        = BooleanFlagOn(Options, FILE_NON_DIRECTORY_FILE);
    SequentialOnly          = BooleanFlagOn(Options, FILE_SEQUENTIAL_ONLY);
    NoIntermediateBuffering = BooleanFlagOn(Options, FILE_NO_INTERMEDIATE_BUFFERING);
    NoEaKnowledge           = BooleanFlagOn(Options, FILE_NO_EA_KNOWLEDGE);
    DeleteOnClose           = BooleanFlagOn(Options, FILE_DELETE_ON_CLOSE);
    TemporaryFile           = BooleanFlagOn(IrpSp->Parameters.Create.FileAttributes,
                                            FILE_ATTRIBUTE_TEMPORARY );
    IsPagingFile            = BooleanFlagOn(IrpSp->Flags, SL_OPEN_PAGING_FILE);
    OpenTargetDirectory     = BooleanFlagOn(IrpSp->Flags, SL_OPEN_TARGET_DIRECTORY);

    /* Calculate create disposition */
    CreateDisposition = (Options >> 24) & 0x000000ff;

    /* Get Create/Open directory flags based on it */
    CreateDirectory = (BOOLEAN)(IsDirectoryFile &&
                                ((CreateDisposition == FILE_CREATE) ||
                                 (CreateDisposition == FILE_OPEN_IF)));

    OpenDirectory   = (BOOLEAN)(IsDirectoryFile &&
                                ((CreateDisposition == FILE_OPEN) ||
                                 (CreateDisposition == FILE_OPEN_IF)));

    /* Validate parameters: directory/nondirectory mismatch and
       AllocationSize being more than 4GB */
    if ((IsDirectoryFile && NonDirectoryFile) ||
        Irp->Overlay.AllocationSize.HighPart != 0)
    {
        FatCompleteRequest(IrpContext, Irp, STATUS_INVALID_PARAMETER);

        DPRINT1("FatiCreate: STATUS_INVALID_PARAMETER\n", 0);
        return STATUS_INVALID_PARAMETER;
    }

    /* Acquire the VCB lock exclusively */
    if (!FatAcquireExclusiveVcb(IrpContext, Vcb))
    {
        // TODO: Postpone the IRP for later processing
        ASSERT(FALSE);
        return STATUS_NOT_IMPLEMENTED;
    }

    // TODO: Verify the VCB

    /* If VCB is locked, then no file openings are possible */
    if (Vcb->State & VCB_STATE_FLAG_LOCKED)
    {
        DPRINT1("This volume is locked\n");
        Status = STATUS_ACCESS_DENIED;

        /* Set volume dismount status */
        if (Vcb->Condition != VcbGood)
            Status = STATUS_VOLUME_DISMOUNTED;

        /* Cleanup and return */
        FatReleaseVcb(IrpContext, Vcb);
        FatCompleteRequest(IrpContext, Irp, Status);
        return Status;
    }

    /* Check if the volume is write protected and disallow DELETE_ON_CLOSE */
    if (DeleteOnClose & FlagOn(Vcb->State, VCB_STATE_FLAG_WRITE_PROTECTED))
    {
        ASSERT(FALSE);
        return STATUS_NOT_IMPLEMENTED;
    }

    // TODO: Make sure EAs aren't supported on FAT32

    /* Check if it's a volume open request */
    if (FileName.Length == 0)
    {
        /* Test related FO to be sure */
        if (!RelatedFO ||
            FatDecodeFileObject(RelatedFO, &DecodedVcb, &Fcb, &Ccb) == UserVolumeOpen)
        {
            /* Check parameters */
            if (IsDirectoryFile || OpenTargetDirectory)
            {
                Status = IsDirectoryFile ? STATUS_NOT_A_DIRECTORY : STATUS_INVALID_PARAMETER;

                /* Unlock VCB */
                FatReleaseVcb(IrpContext, Vcb);

                /* Complete the request and return */
                FatCompleteRequest(IrpContext, Irp, Status);
                return Status;
            }

            /* It is indeed a volume open request */
            Iosb = FatiOpenVolume(IrpContext,
                                  FileObject,
                                  Vcb,
                                  DesiredAccess,
                                  ShareAccess,
                                  CreateDisposition);

            /* Set resulting information */
            Irp->IoStatus.Information = Iosb.Information;

            /* Unlock VCB */
            FatReleaseVcb(IrpContext, Vcb);

            /* Complete the request and return */
            FatCompleteRequest(IrpContext, Irp, Iosb.Status);
            return Iosb.Status;
        }
    }

    /* Check if this is a relative open */
    if (RelatedFO)
    {
        /* Decode the file object */
        TypeOfOpen = FatDecodeFileObject(RelatedFO,
                                         &RelatedVcb,
                                         &RelatedDcb,
                                         &RelatedCcb);

        /* Check open type */
        if (TypeOfOpen != UserFileOpen &&
            TypeOfOpen != UserDirectoryOpen)
        {
            DPRINT1("Invalid file object!\n");

            Status = STATUS_OBJECT_PATH_NOT_FOUND;

            /* Cleanup and return */
            FatReleaseVcb(IrpContext, Vcb);
            FatCompleteRequest(IrpContext, Irp, Status);
            return Status;
        }

        /* File path must be relative */
        if (FileName.Length != 0 &&
            FileName.Buffer[0] == L'\\')
        {
            Status = STATUS_OBJECT_NAME_INVALID;

            /* The name is absolute, fail */
            FatReleaseVcb(IrpContext, Vcb);
            FatCompleteRequest(IrpContext, Irp, Status);
            return Status;
        }

        /* Make sure volume is the same */
        ASSERT(RelatedVcb == Vcb);

        /* Save VPB */
        FileObject->Vpb = RelatedFO->Vpb;

        /* Set parent DCB */
        ParentDcb = RelatedDcb;

        DPRINT("Opening file '%wZ' relatively to '%wZ'\n", &FileName, &ParentDcb->FullFileName);
    }
    else
    {
        /* Absolute open */
        if ((FileName.Length == sizeof(WCHAR)) &&
            (FileName.Buffer[0] == L'\\'))
        {
            /* Check if it's ok to open it */
            if (NonDirectoryFile)
            {
                DPRINT1("Trying to open root dir as a file\n");
                Status = STATUS_FILE_IS_A_DIRECTORY;

                /* Cleanup and return */
                FatReleaseVcb(IrpContext, Vcb);
                FatCompleteRequest(IrpContext, Irp, Status);
                return Status;
            }

            /* Check for target directory on a root dir */
            if (OpenTargetDirectory)
            {
                Status = STATUS_INVALID_PARAMETER;

                /* Cleanup and return */
                FatReleaseVcb(IrpContext, Vcb);
                FatCompleteRequest(IrpContext, Irp, Status);
                return Status;
            }

            /* Check delete on close on a root dir */
            if (DeleteOnClose)
            {
                Status = STATUS_CANNOT_DELETE;

                /* Cleanup and return */
                FatReleaseVcb(IrpContext, Vcb);
                FatCompleteRequest(IrpContext, Irp, Status);
                return Status;
            }

            /* Call root directory open routine */
            Iosb = FatiOpenRootDcb(IrpContext,
                                   FileObject,
                                   Vcb,
                                   DesiredAccess,
                                   ShareAccess,
                                   CreateDisposition);

            Irp->IoStatus.Information = Iosb.Information;

            /* Cleanup and return */
            FatReleaseVcb(IrpContext, Vcb);
            FatCompleteRequest(IrpContext, Irp, Iosb.Status);
            return Iosb.Status;
        }
        else
        {
            /* Not a root dir */
            ParentDcb = Vcb->RootDcb;
            DPRINT("ParentDcb %p\n", ParentDcb);
        }
    }

    /* Check for backslash at the end */
    if (FileName.Length &&
        FileName.Buffer[FileName.Length / sizeof(WCHAR) - 1] == L'\\')
    {
        /* Cut it out */
        FileName.Length -= sizeof(WCHAR);

        /* Remember we cut it */
        EndBackslash = TRUE;
    }

    /* Ensure the name is set */
    if (!ParentDcb->FullFileName.Buffer)
    {
        /* Set it if it's missing */
        FatSetFullFileNameInFcb(IrpContext, ParentDcb);
    }

    /* Check max path length */
    if (ParentDcb->FullFileName.Length + FileName.Length + sizeof(WCHAR) <= FileName.Length)
    {
        DPRINT1("Max length is way off\n");
        Iosb.Status = STATUS_OBJECT_NAME_INVALID;
        ASSERT(FALSE);
    }

    /* Loop through FCBs to find a good one */
    while (TRUE)
    {
        Fcb = ParentDcb;

        /* Dissect the name */
        RemainingPart = FileName;
        while (RemainingPart.Length)
        {
            FsRtlDissectName(RemainingPart, &FirstName, &NextName);

            /* Check for validity */
            if ((NextName.Length && NextName.Buffer[0] == L'\\') ||
                (NextName.Length > 255 * sizeof(WCHAR)))
            {
                /* The name is invalid */
                DPRINT1("Invalid name found\n");
                Iosb.Status = STATUS_OBJECT_NAME_INVALID;
                ASSERT(FALSE);
            }

            /* Convert the name to ANSI */
            AnsiFirstName.Buffer = ExAllocatePool(PagedPool, FirstName.Length);
            AnsiFirstName.Length = 0;
            AnsiFirstName.MaximumLength = FirstName.Length;
            Status = RtlUpcaseUnicodeStringToCountedOemString(&AnsiFirstName, &FirstName, FALSE);

            if (!NT_SUCCESS(Status))
            {
                DPRINT1("RtlUpcaseUnicodeStringToCountedOemString() failed with 0x%08x\n", Status);
                ASSERT(FALSE);
                NextFcb = NULL;
                AnsiFirstName.Length = 0;
            }
            else
            {
                /* Find the coresponding FCB */
                NextFcb = FatFindFcb(IrpContext,
                                     &Fcb->Dcb.SplayLinksAnsi,
                                     (PSTRING)&AnsiFirstName,
                                     &OpenedAsDos);
            }

            /* If nothing found - try with unicode */
            if (!NextFcb && Fcb->Dcb.SplayLinksUnicode)
            {
                FileNameUpcased.Buffer = FsRtlAllocatePool(PagedPool, FirstName.Length);
                FileNameUpcased.Length = 0;
                FileNameUpcased.MaximumLength = FirstName.Length;

                /* Downcase and then upcase to normalize it */
                Status = RtlDowncaseUnicodeString(&FileNameUpcased, &FirstName, FALSE);
                Status = RtlUpcaseUnicodeString(&FileNameUpcased, &FileNameUpcased, FALSE);

                /* Try to find FCB again using unicode name */
                NextFcb = FatFindFcb(IrpContext,
                                     &Fcb->Dcb.SplayLinksUnicode,
                                     (PSTRING)&FileNameUpcased,
                                     &OpenedAsDos);
            }

            /* Move to the next FCB */
            if (NextFcb)
            {
                Fcb = NextFcb;
                RemainingPart = NextName;
            }

            /* Break out of this loop if nothing can be found */
            if (!NextFcb ||
                NextName.Length == 0 ||
                FatNodeType(NextFcb) == FAT_NTC_FCB)
            {
                break;
            }
        }

        /* Ensure remaining name doesn't start from a backslash */
        if (RemainingPart.Length &&
            RemainingPart.Buffer[0] == L'\\')
        {
            /* Cut it */
            RemainingPart.Buffer++;
            RemainingPart.Length -= sizeof(WCHAR);
        }

        if (Fcb->Condition == FcbGood)
        {
            /* Good FCB, break out of the loop */
            break;
        }
        else
        {
            ASSERT(FALSE);
        }
    }

    /* Treat page file in a special way */
    if (IsPagingFile)
    {
        UNIMPLEMENTED;
        // FIXME: System file too
    }

    /* Make sure there is no pending delete on a higher-level FCB */
    if (Fcb->State & FCB_STATE_DELETE_ON_CLOSE)
    {
        Iosb.Status = STATUS_DELETE_PENDING;

        /* Cleanup and return */
        FatReleaseVcb(IrpContext, Vcb);

        /* Complete the request */
        FatCompleteRequest(IrpContext, Irp, Iosb.Status);

        return Iosb.Status;
    }

    /* We have a valid FCB now */
    if (!RemainingPart.Length)
    {
        /* Check for target dir open */
        if (OpenTargetDirectory)
        {
            DPRINT1("Opening target dir is missing\n");
            ASSERT(FALSE);
        }

        /* Check this FCB's type */
        if (FatNodeType(Fcb) == FAT_NTC_ROOT_DCB ||
            FatNodeType(Fcb) == FAT_NTC_DCB)
        {
            /* Open a directory */
            if (NonDirectoryFile)
            {
                /* Forbidden */
                Iosb.Status = STATUS_FILE_IS_A_DIRECTORY;
                ASSERT(FALSE);
                return Iosb.Status;
            }

            /* Open existing DCB */
            Iosb = FatiOpenExistingDcb(IrpContext,
                                       FileObject,
                                       Vcb,
                                       Fcb,
                                       DesiredAccess,
                                       ShareAccess,
                                       CreateDisposition,
                                       NoEaKnowledge,
                                       DeleteOnClose);

            /* Save information */
            Irp->IoStatus.Information = Iosb.Information;

            /* Unlock VCB */
            FatReleaseVcb(IrpContext, Vcb);

            /* Complete the request */
            FatCompleteRequest(IrpContext, Irp, Iosb.Status);

            return Iosb.Status;
        }
        else if (FatNodeType(Fcb) == FAT_NTC_FCB)
        {
            /* Open a file */
            if (OpenDirectory)
            {
                /* Forbidden */
                Iosb.Status = STATUS_NOT_A_DIRECTORY;
                ASSERT(FALSE);
                return Iosb.Status;
            }

            /* Check for trailing backslash */
            if (EndBackslash)
            {
                /* Forbidden */
                Iosb.Status = STATUS_OBJECT_NAME_INVALID;
                ASSERT(FALSE);
                return Iosb.Status;
            }

            Iosb = FatiOpenExistingFcb(IrpContext,
                                       FileObject,
                                       Vcb,
                                       Fcb,
                                       DesiredAccess,
                                       ShareAccess,
                                       AllocationSize,
                                       EaBuffer,
                                       EaLength,
                                       FileAttributes,
                                       CreateDisposition,
                                       NoEaKnowledge,
                                       DeleteOnClose,
                                       OpenedAsDos,
                                       &OplockPostIrp);

            /* Check if it's pending */
            if (Iosb.Status != STATUS_PENDING)
            {
                /* In case of success set cache supported flag */
                if (NT_SUCCESS(Iosb.Status) && !NoIntermediateBuffering)
                {
                    SetFlag(FileObject->Flags, FO_CACHE_SUPPORTED);
                }

                /* Save information */
                Irp->IoStatus.Information = Iosb.Information;

                /* Unlock VCB */
                FatReleaseVcb(IrpContext, Vcb);

                /* Complete the request */
                FatCompleteRequest(IrpContext, Irp, Iosb.Status);

                return Iosb.Status;
            }
            else
            {
                /* Queue this IRP */
                UNIMPLEMENTED;
                ASSERT(FALSE);
            }
        }
        else
        {
            /* Unexpected FCB type */
            KeBugCheckEx(FAT_FILE_SYSTEM, __LINE__, (ULONG_PTR)Fcb, 0, 0);
        }
    }

    /* During parsing we encountered a part which has no attached FCB/DCB.
    Check that the parent is really DCB and not FCB */
    if (FatNodeType(Fcb) != FAT_NTC_ROOT_DCB &&
        FatNodeType(Fcb) != FAT_NTC_DCB)
    {
        DPRINT1("Weird FCB node type %x, expected DCB or root DCB\n", FatNodeType(Fcb));
        ASSERT(FALSE);
    }

    /* Create additional DCBs for all path items */
    ParentDcb = Fcb;
    while (TRUE)
    {
        if (FirstRun)
        {
            RemainingPart = NextName;
            if (AnsiFirstName.Length)
                Status = STATUS_SUCCESS;
            else
                Status = STATUS_UNMAPPABLE_CHARACTER;

            /* First run init is done */
            FirstRun = FALSE;
        }
        else
        {
            FsRtlDissectName(RemainingPart, &FirstName, &RemainingPart);

            /* Check for validity */
            if ((RemainingPart.Length && RemainingPart.Buffer[0] == L'\\') ||
                (NextName.Length > 255 * sizeof(WCHAR)))
            {
                /* The name is invalid */
                DPRINT1("Invalid name found\n");
                Iosb.Status = STATUS_OBJECT_NAME_INVALID;
                ASSERT(FALSE);
            }

            /* Convert the name to ANSI */
            AnsiFirstName.Buffer = ExAllocatePool(PagedPool, FirstName.Length);
            AnsiFirstName.Length = 0;
            AnsiFirstName.MaximumLength = FirstName.Length;
            Status = RtlUpcaseUnicodeStringToCountedOemString(&AnsiFirstName, &FirstName, FALSE);
        }

        if (!NT_SUCCESS(Status))
        {
            ASSERT(FALSE);
        }

        DPRINT("FirstName %wZ, RemainingPart %wZ\n", &FirstName, &RemainingPart);

        /* Break if came to the end */
        if (!RemainingPart.Length) break;

        /* Create a DCB for this entry */
        ParentDcb = FatCreateDcb(IrpContext,
                                 Vcb,
                                 ParentDcb,
                                 NULL);

        /* Set its name */
        FatSetFullNameInFcb(ParentDcb, &FirstName);
    }

    /* Try to open it and get a result, saying if this is a dir or a file */
    FfError = FatiTryToOpen(FileObject, Vcb);

    /* Check if we need to open target directory */
    if (OpenTargetDirectory)
    {
        // TODO: Open target directory
        UNIMPLEMENTED;
    }

    /* Check, if path is a existing directory or file */
    if (FfError == FF_ERR_FILE_OBJECT_IS_A_DIR ||
        FfError == FF_ERR_FILE_ALREADY_OPEN ||
        FfError == FF_ERR_NONE)
    {
        if (FfError == FF_ERR_FILE_OBJECT_IS_A_DIR)
        {
            if (NonDirectoryFile)
            {
                DPRINT1("Can't open dir as a file\n");

                /* Unlock VCB */
                FatReleaseVcb(IrpContext, Vcb);

                /* Complete the request */
                Iosb.Status = STATUS_FILE_IS_A_DIRECTORY;
                FatCompleteRequest(IrpContext, Irp, Iosb.Status);
                return Iosb.Status;
            }

            /* Open this directory */
            Iosb = FatiOpenExistingDir(IrpContext,
                FileObject,
                Vcb,
                ParentDcb,
                DesiredAccess,
                ShareAccess,
                AllocationSize,
                EaBuffer,
                EaLength,
                FileAttributes,
                CreateDisposition,
                DeleteOnClose);

            Irp->IoStatus.Information = Iosb.Information;

            /* Unlock VCB */
            FatReleaseVcb(IrpContext, Vcb);

            /* Complete the request */
            FatCompleteRequest(IrpContext, Irp, Iosb.Status);

            return Iosb.Status;
        }
        else
        {
            /* This is opening an existing file */
            if (OpenDirectory)
            {
                /* But caller wanted a dir */
                Status = STATUS_NOT_A_DIRECTORY;

                /* Unlock VCB */
                FatReleaseVcb(IrpContext, Vcb);

                /* Complete the request */
                FatCompleteRequest(IrpContext, Irp, Status);

                return Status;
            }

            /* If end backslash here, then it's definately not permitted,
            since we're opening files here */
            if (EndBackslash)
            {
                /* Unlock VCB */
                FatReleaseVcb(IrpContext, Vcb);

                /* Complete the request */
                Iosb.Status = STATUS_OBJECT_NAME_INVALID;
                FatCompleteRequest(IrpContext, Irp, Iosb.Status);
                return Iosb.Status;
            }

            /* Try to open the file */
            Iosb = FatiOpenExistingFile(IrpContext,
                                        FileObject,
                                        Vcb,
                                        ParentDcb,
                                        DesiredAccess,
                                        ShareAccess,
                                        AllocationSize,
                                        EaBuffer,
                                        EaLength,
                                        FileAttributes,
                                        CreateDisposition,
                                        FALSE,
                                        DeleteOnClose,
                                        OpenedAsDos);

            /* In case of success set cache supported flag */
            if (NT_SUCCESS(Iosb.Status) && !NoIntermediateBuffering)
            {
                SetFlag(FileObject->Flags, FO_CACHE_SUPPORTED);
            }

            Irp->IoStatus.Information = Iosb.Information;

            /* Unlock VCB */
            FatReleaseVcb(IrpContext, Vcb);

            /* Complete the request */
            FatCompleteRequest(IrpContext, Irp, Iosb.Status);

            return Iosb.Status;
        }
    }

    /* We come here only in the case when a new file is created */
    //ASSERT(FALSE);
    DPRINT1("TODO: Create a new file/directory, called '%wZ'\n", &IrpSp->FileObject->FileName);

    Status = STATUS_NOT_IMPLEMENTED;

    /* Unlock VCB */
    FatReleaseVcb(IrpContext, Vcb);

    /* Complete the request */
    FatCompleteRequest(IrpContext, Irp, Status);

    return Status;
}

NTSTATUS
NTAPI
FatCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    PFAT_IRP_CONTEXT IrpContext;
    NTSTATUS Status;

    /* If it's called with our Disk FS device object - it's always open */
    // TODO: Add check for CDROM FS device object
    if (DeviceObject == FatGlobalData.DiskDeviceObject)
    {
        /* Complete the request and return success */
        Irp->IoStatus.Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = FILE_OPENED;

        IoCompleteRequest(Irp, IO_DISK_INCREMENT);

        return STATUS_SUCCESS;
    }

    /* Enter FsRtl critical region */
    FsRtlEnterFileSystem();

    /* Build an irp context */
    IrpContext = FatBuildIrpContext(Irp, TRUE);

    /* Call internal function */
    Status = FatiCreate(IrpContext, Irp);

    /* Leave FsRtl critical region */
    FsRtlExitFileSystem();

    return Status;
}

/* EOF */