create.c File Reference

#include "cdprocs.h"

Include dependency graph for create.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (CDFS_BUG_CHECK_CREATE)

Functions
	_When_ (RelatedTypeOfOpen !=UnopenedFileObject, _At_(RelatedCcb, _In_))
	_Requires_lock_held_ (_Global_critical_region_)

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (CDFS_BUG_CHECK_CREATE)

Definition at line 23 of file create.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 1477 of file create.c.

{
    NTSTATUS Status = STATUS_ACCESS_DENIED;
 
    BOOLEAN UnlockVcb = FALSE;
    BOOLEAN Found;
 
    ULONG StreamOffset;
 
    NODE_TYPE_CODE NodeTypeCode;
    TYPE_OF_OPEN TypeOfOpen;
 
    FILE_ENUM_CONTEXT FileContext;
    BOOLEAN CleanupFileContext = FALSE;
 
    COMPOUND_PATH_ENTRY CompoundPathEntry = {{0}};/* ReactOS Change: GCC "missing braces around initializer" */
    BOOLEAN CleanupCompoundPathEntry = FALSE;
 
    FILE_ID FileId;
    FILE_ID ParentFileId;
 
    PFCB NextFcb;
 
    PAGED_CODE();
 
    //
    //  Extract the FileId from the FileObject.
    //
 
    RtlCopyMemory( &FileId, IrpSp->FileObject->FileName.Buffer, sizeof( FILE_ID ));
 
    //
    //  Use a try-finally to facilitate cleanup.
    //
 
    _SEH2_TRY {
 
        //
        //  Go ahead and figure out the TypeOfOpen and NodeType.  We can
        //  get these from the input FileId.
        //
 
        if (CdFidIsDirectory( FileId )) {
 
            TypeOfOpen = UserDirectoryOpen;
            NodeTypeCode = CDFS_NTC_FCB_INDEX;
 
            //
            //  If the offset isn't zero then the file Id is bad.
            //
 
            if (CdQueryFidDirentOffset( FileId ) != 0) {
 
                try_return( Status = STATUS_INVALID_PARAMETER );
            }
 
        } else {
 
            TypeOfOpen = UserFileOpen;
            NodeTypeCode = CDFS_NTC_FCB_DATA;
        }
 
        //
        //  Acquire the Vcb and check if there is already an Fcb.
        //  If not we will need to carefully verify the Fcb.
        //  We will post the request if we don't find the Fcb and this
        //  request can't wait.
        //
 
        CdLockVcb( IrpContext, Vcb );
        UnlockVcb = TRUE;
 
        NextFcb = CdLookupFcbTable( IrpContext, Vcb, FileId );
 
        if (NextFcb == NULL) {
 
            //
            //  Get the path table offset from the file id.
            //
 
            StreamOffset = CdQueryFidPathTableOffset( FileId );
 
            //
            //  Build the parent FileId for this and try looking it
            //  up in the PathTable.
            //
 
            CdSetFidDirentOffset( ParentFileId, 0 );
            CdSetFidPathTableOffset( ParentFileId, StreamOffset );
            CdFidSetDirectory( ParentFileId );
 
            NextFcb = CdLookupFcbTable( IrpContext, Vcb, ParentFileId );
 
            //
            //  If not present then walk through the PathTable to this point.
            //
 
            if (NextFcb == NULL) {
 
                CdUnlockVcb( IrpContext, Vcb );
                UnlockVcb = FALSE;
 
                //
                //  Check that the path table offset lies within the path
                //  table.
                //
 
                if (StreamOffset > Vcb->PathTableFcb->FileSize.LowPart) {
 
                    try_return( Status = STATUS_INVALID_PARAMETER );
                }
 
                CdInitializeCompoundPathEntry( IrpContext, &CompoundPathEntry );
                CleanupCompoundPathEntry = TRUE;
 
                //
                //  Start at the first entry in the PathTable.
                //
 
                CdLookupPathEntry( IrpContext,
                                   Vcb->PathTableFcb->StreamOffset,
                                   1,
                                   TRUE,
                                   &CompoundPathEntry );
 
                //
                //  Continue looking until we have passed our target offset.
                //
 
                while (TRUE) {
 
                    //
                    //  Move to the next entry.
                    //
 
                    Found = CdLookupNextPathEntry( IrpContext,
                                                   &CompoundPathEntry.PathContext,
                                                   &CompoundPathEntry.PathEntry );
 
                    //
                    //  If we didn't find the entry or are beyond it then the
                    //  input Id is invalid.
                    //
 
                    if (!Found ||
                        (CompoundPathEntry.PathEntry.PathTableOffset > StreamOffset)) {
 
                        try_return( Status = STATUS_INVALID_PARAMETER );
                    }
                }
 
                //
                //  If the FileId specified a directory then we have found
                //  the entry.  Make sure our caller wanted to open a directory.
                //
 
                if ((TypeOfOpen == UserDirectoryOpen) &&
                    FlagOn( IrpSp->Parameters.Create.Options, FILE_NON_DIRECTORY_FILE )) {
 
                    try_return( Status = STATUS_FILE_IS_A_DIRECTORY );
                }
 
                //
                //  Lock the Vcb and create the Fcb if necessary.
                //
 
                CdLockVcb( IrpContext, Vcb );
                UnlockVcb = TRUE;
 
                NextFcb = CdCreateFcb( IrpContext, ParentFileId, NodeTypeCode, &Found );
 
                //
                //  It's possible that someone got in here ahead of us.
                //
 
                if (!Found) {
 
                    CdInitializeFcbFromPathEntry( IrpContext,
                                                  NextFcb,
                                                  NULL,
                                                  &CompoundPathEntry.PathEntry );
                }
 
                //
                //  If the user wanted to open a directory then we have found
                //  it.  Store this Fcb into the CurrentFcb and skip the
                //  directory scan.
                //
 
                if (TypeOfOpen == UserDirectoryOpen) {
 
                    *CurrentFcb = NextFcb;
                    NextFcb = NULL;
                }
            }
 
            //
            //  Perform the directory scan if we don't already have our target.
            //
 
            if (NextFcb != NULL) {
 
                //
                //  Acquire the parent.  We currently own the Vcb lock so
                //  do this without waiting first.
                //
 
                if (!CdAcquireFcbExclusive( IrpContext,
                                            NextFcb,
                                            TRUE )) {
 
                    NextFcb->FcbReference += 1;
                    CdUnlockVcb( IrpContext, Vcb );
 
                    CdAcquireFcbExclusive( IrpContext, NextFcb, FALSE );
 
                    CdLockVcb( IrpContext, Vcb );
                    NextFcb->FcbReference -= 1;
                    CdUnlockVcb( IrpContext, Vcb );
 
                } else {
 
                    CdUnlockVcb( IrpContext, Vcb );
                }
 
                UnlockVcb = FALSE;
 
                //
                //  Set up the CurrentFcb pointers.  We know there was
                //  no previous parent in this case.
                //
 
                *CurrentFcb = NextFcb;
 
                //
                //  Calculate the offset in the stream.
                //
 
                StreamOffset = CdQueryFidDirentOffset( FileId );
 
                //
                //  Create the stream file if it doesn't exist.  This will update
                //  the Fcb with the size from the self entry.
                //
 
                CdVerifyOrCreateDirStreamFile( IrpContext, NextFcb);
 
                //
                //  If our offset is beyond the end of the directory then the
                //  FileId is invalid.
                //
 
                if (StreamOffset > NextFcb->FileSize.LowPart) {
 
                    try_return( Status = STATUS_INVALID_PARAMETER );
                }
 
                //
                //  Otherwise position ourselves at the self entry and walk
                //  through dirent by dirent until this location is found.
                //
 
                CdInitializeFileContext( IrpContext, &FileContext );
                CdLookupInitialFileDirent( IrpContext,
                                           NextFcb,
                                           &FileContext,
                                           NextFcb->StreamOffset );
 
                CleanupFileContext = TRUE;
 
                while (TRUE) {
 
                    //
                    //  Move to the first entry of the next file.
                    //
 
                    Found = CdLookupNextInitialFileDirent( IrpContext,
                                                           NextFcb,
                                                           &FileContext );
 
                    //
                    //  If we didn't find the entry or are beyond it then the
                    //  input Id is invalid.
                    //
 
                    if (!Found ||
                        (FileContext.InitialDirent->Dirent.DirentOffset > StreamOffset)) {
 
                        try_return( Status = STATUS_INVALID_PARAMETER );
                    }
                }
 
                //
                //  This better not be a directory.  Directory FileIds must
                //  refer to the self entry for directories.
                //
 
                if (FlagOn( FileContext.InitialDirent->Dirent.DirentFlags,
                            CD_ATTRIBUTE_DIRECTORY )) {
 
                    try_return( Status = STATUS_INVALID_PARAMETER );
                }
 
                //
                //  Check that our caller wanted to open a file.
                //
 
                if (FlagOn( IrpSp->Parameters.Create.Options, FILE_DIRECTORY_FILE )) {
 
                    try_return( Status = STATUS_NOT_A_DIRECTORY );
                }
 
                //
                //  Otherwise we want to collect all of the dirents for this file
                //  and create an Fcb with this.
                //
 
                CdLookupLastFileDirent( IrpContext, NextFcb, &FileContext );
 
                CdLockVcb( IrpContext, Vcb );
                UnlockVcb = TRUE;
 
                NextFcb = CdCreateFcb( IrpContext, FileId, NodeTypeCode, &Found );
 
                //
                //  It's possible that someone has since created this Fcb since we
                //  first checked.  If so then can simply use this.  Otherwise
                //  we need to initialize a new Fcb and attach it to our parent
                //  and insert it into the Fcb Table.
                //
 
                if (!Found) {
 
                    CdInitializeFcbFromFileContext( IrpContext,
                                                    NextFcb,
                                                    *CurrentFcb,
                                                    &FileContext );
                }
            }
 
        //
        //  We have the Fcb.  Check that the type of the file is compatible with
        //  the desired type of file to open.
        //
 
        } else {
 
            if (FlagOn( NextFcb->FileAttributes, FILE_ATTRIBUTE_DIRECTORY )) {
 
                if (FlagOn( IrpSp->Parameters.Create.Options, FILE_NON_DIRECTORY_FILE )) {
 
                    try_return( Status = STATUS_FILE_IS_A_DIRECTORY );
                }
 
            } else if (FlagOn( IrpSp->Parameters.Create.Options, FILE_DIRECTORY_FILE )) {
 
                try_return( Status = STATUS_NOT_A_DIRECTORY );
            }
        }
 
        //
        //  If we have a the previous Fcb and have inserted the next Fcb into
        //  the Fcb Table.  It is safe to release the current Fcb if present
        //  since it is referenced through the child Fcb.
        //
 
        if (*CurrentFcb != NULL) {
 
            CdReleaseFcb( IrpContext, *CurrentFcb );
        }
 
        //
        //  We now know the Fcb and currently hold the Vcb lock.
        //  Try to acquire this Fcb without waiting.  Otherwise we
        //  need to reference it, drop the Vcb, acquire the Fcb and
        //  then dereference the Fcb.
        //
 
        if (!CdAcquireFcbExclusive( IrpContext, NextFcb, TRUE )) {
 
            NextFcb->FcbReference += 1;
 
            CdUnlockVcb( IrpContext, Vcb );
 
            CdAcquireFcbExclusive( IrpContext, NextFcb, FALSE );
 
            CdLockVcb( IrpContext, Vcb );
            NextFcb->FcbReference -= 1;
            CdUnlockVcb( IrpContext, Vcb );
 
        } else {
 
            CdUnlockVcb( IrpContext, Vcb );
        }
 
        UnlockVcb = FALSE;
 
        //
        //  Move to this Fcb.
        //
 
        *CurrentFcb = NextFcb;
 
        // Lock object is acquired using internal state
        _Analysis_suppress_lock_checking_(NextFcb->FcbNonpaged->FcbResource);
 
        //
        //  Check the requested access on this Fcb.
        //
 
        if (!CdIllegalFcbAccess( IrpContext,
                                 TypeOfOpen,
                                 IrpSp->Parameters.Create.SecurityContext->DesiredAccess )) {
 
            //
            //  Call our worker routine to complete the open.
            //
 
            Status = CdCompleteFcbOpen( IrpContext,
                                        IrpSp,
                                        Vcb,
                                        CurrentFcb,
                                        TypeOfOpen,
                                        CCB_FLAG_OPEN_BY_ID,
                                        IrpSp->Parameters.Create.SecurityContext->DesiredAccess );
 
        }
 
    try_exit:  NOTHING;
    } _SEH2_FINALLY {
 
        if (UnlockVcb) {
 
            CdUnlockVcb( IrpContext, Vcb );
        }
 
        if (CleanupFileContext) {
 
            CdCleanupFileContext( IrpContext, &FileContext );
        }
 
        if (CleanupCompoundPathEntry) {
 
            CdCleanupCompoundPathEntry( IrpContext, &CompoundPathEntry );
        }
    } _SEH2_END;
 
    return Status;
}

_When_()

_When_	(	RelatedTypeOfOpen !	= UnopenedFileObject,
		_At_(RelatedCcb, _In_)
	)

Definition at line 29 of file create.c.

                        :26165, "Esp:1153")
#endif
CdCommonCreate (
    _Inout_ PIRP_CONTEXT IrpContext,
    _Inout_ PIRP Irp
    )
 
/*++
 
Routine Description:
 
    This is the common routine for opening a file called by both the
    Fsp and Fsd threads.
 
    The file can be opened either by name or by file Id either with or without
    a relative name.  The file name field in the file object passed to this routine
    contains either a unicode string or a 64 bit value which is the file Id.
    If this is not a Joliet disk then we will convert the unicode name to
    an Oem string in this routine.  If there is a related file object with
    a name then we will already have converted that name to Oem.
 
    We will store the full name for the file in the file object on a successful
    open.  We will allocate a larger buffer if necessary and combine the
    related and file object names.  The only exception is the relative open
    when the related file object is for an OpenByFileId file.  If we need to
    allocate a buffer for a case insensitive name then we allocate it at
    the tail of the buffer we will store into the file object.  The upcased
    portion will begin immediately after the name defined by the FileName
    in the file object.
 
    Once we have the full name in the file object we don't want to split the
    name in the event of a retry.  We use a flag in the IrpContext to indicate
    that the name has been split.
 
Arguments:
 
    Irp - Supplies the Irp to process
 
Return Value:
 
    NTSTATUS - This is the status from this open operation.
 
--*/
 
{
    NTSTATUS Status = STATUS_SUCCESS;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    PFILE_OBJECT FileObject;
 
    COMPOUND_PATH_ENTRY CompoundPathEntry = {{0}};/* ReactOS Change: GCC "missing braces around initializer" */
    BOOLEAN CleanupCompoundPathEntry = FALSE;
 
    FILE_ENUM_CONTEXT FileContext = {0};
    BOOLEAN CleanupFileContext = FALSE;
    BOOLEAN FoundEntry;
 
    PVCB Vcb;
 
    BOOLEAN OpenByFileId;
    BOOLEAN IgnoreCase;
    ULONG CreateDisposition;
 
    BOOLEAN ShortNameMatch;
    ULONG ShortNameDirentOffset;
 
    BOOLEAN VolumeOpen = FALSE;
 
    //
    //  We will be acquiring and releasing file Fcb's as we move down the
    //  directory tree during opens.  At any time we need to know the deepest
    //  point we have traversed down in the tree in case we need to cleanup
    //  any structures created here.
    //
    //  CurrentFcb - represents this point.  If non-null it means we have
    //      acquired it and need to release it in finally clause.
    //
    //  NextFcb - represents the NextFcb to walk to but haven't acquired yet.
    //
 
    TYPE_OF_OPEN RelatedTypeOfOpen = UnopenedFileObject;
    PFILE_OBJECT RelatedFileObject;
    PCCB RelatedCcb = NULL;
 
    PFCB NextFcb;
    PFCB CurrentFcb = NULL;
 
    //
    //  During the open we need to combine the related file object name
    //  with the remaining name.  We also may need to upcase the file name
    //  in order to do a case-insensitive name comparison.  We also need
    //  to restore the name in the file object in the event that we retry
    //  the request.  We use the following string variables to manage the
    //  name.  We will can put these strings into either Unicode or Ansi
    //  form.
    //
    //  FileName - Pointer to name as currently stored in the file
    //      object.  We store the full name into the file object early in
    //      the open operation.
    //
    //  RelatedFileName - Pointer to the name in the related file object.
    //
    //  RemainingName - String containing remaining name to parse.
    //
    //  MatchingName - Address of name structure in FileContext which matched.
    //      We need this to know whether we matched the long or short name.
    //
 
    PUNICODE_STRING FileName;
    PUNICODE_STRING RelatedFileName = NULL;
 
    CD_NAME RemainingName = {{0}};/* ReactOS Change: GCC "missing braces around initializer" */
    CD_NAME FinalName;
    PCD_NAME MatchingName = NULL;
 
    PAGED_CODE();
 
    //
    //  If we were called with our file system device object instead of a
    //  volume device object, just complete this request with STATUS_SUCCESS.
    //
 
    if (IrpContext->Vcb == NULL) {
 
        CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
        return STATUS_SUCCESS;
    }
 
    //
    //  Get create parameters from the Irp.
    //
 
    OpenByFileId = BooleanFlagOn( IrpSp->Parameters.Create.Options, FILE_OPEN_BY_FILE_ID );
    IgnoreCase = !BooleanFlagOn( IrpSp->Flags, SL_CASE_SENSITIVE );
    CreateDisposition = (IrpSp->Parameters.Create.Options >> 24) & 0x000000ff;
 
    //
    //  Do some preliminary checks to make sure the operation is supported.
    //  We fail in the following cases immediately.
    //
    //      - Open a paging file.
    //      - Open a target directory.
    //      - Open a file with Eas.
    //      - Create a file.
    //
 
    if (FlagOn( IrpSp->Flags, SL_OPEN_PAGING_FILE | SL_OPEN_TARGET_DIRECTORY) ||
        (IrpSp->Parameters.Create.EaLength != 0) ||
        (CreateDisposition == FILE_CREATE)) {
 
        CdCompleteRequest( IrpContext, Irp, STATUS_ACCESS_DENIED );
        return STATUS_ACCESS_DENIED;
    }
 
#if (NTDDI_VERSION >= NTDDI_WIN7)
    //
    //  CDFS does not support FILE_OPEN_REQUIRING_OPLOCK
    //
 
    if (FlagOn( IrpSp->Parameters.Create.Options, FILE_OPEN_REQUIRING_OPLOCK )) {
 
        CdCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
        return STATUS_INVALID_PARAMETER;
    }
#endif
 
    //
    //  Copy the Vcb to a local.  Assume the starting directory is the root.
    //
 
    Vcb = IrpContext->Vcb;
    NextFcb = Vcb->RootIndexFcb;
 
    //
    //  Reference our input parameters to make things easier
    //
 
    FileObject = IrpSp->FileObject;
    RelatedFileObject = NULL;
 
    FileName = &FileObject->FileName;
 
    //
    //  Set up the file object's Vpb pointer in case anything happens.
    //  This will allow us to get a reasonable pop-up.
    //
 
    if ((FileObject->RelatedFileObject != NULL) && !OpenByFileId) {
 
        RelatedFileObject = FileObject->RelatedFileObject;
        FileObject->Vpb = RelatedFileObject->Vpb;
 
        RelatedTypeOfOpen = CdDecodeFileObject( IrpContext, RelatedFileObject, &NextFcb, &RelatedCcb );
 
        //
        //  Fail the request if this is not a user file object.
        //
 
        if (RelatedTypeOfOpen < UserVolumeOpen) {
 
            CdCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
            return STATUS_INVALID_PARAMETER;
        }
 
        //
        //  Remember the name in the related file object.
        //
 
        RelatedFileName = &RelatedFileObject->FileName;
    }
 
    //
    //  If we haven't initialized the names then make sure the strings are valid.
    //  If this an OpenByFileId then verify the file id buffer.
    //
    //  After this routine returns we know that the full name is in the
    //  FileName buffer and the buffer will hold the upcased portion
    //  of the name yet to parse immediately after the full name in the
    //  buffer.  Any trailing backslash has been removed and the flag
    //  in the IrpContext will indicate whether we removed the
    //  backslash.
    //
 
    Status = CdNormalizeFileNames( IrpContext,
                                   Vcb,
                                   OpenByFileId,
                                   IgnoreCase,
                                   RelatedTypeOfOpen,
                                   RelatedCcb,
                                   RelatedFileName,
                                   FileName,
                                   &RemainingName );
 
    //
    //  Return the error code if not successful.
    //
 
    if (!NT_SUCCESS( Status )) {
 
        CdCompleteRequest( IrpContext, Irp, Status );
        return Status;
    }
 
    //
    //  We want to acquire the Vcb.  Exclusively for a volume open, shared otherwise.
    //  The file name is empty for a volume open.
    //
 
    if ((FileName->Length == 0) &&
        (RelatedTypeOfOpen <= UserVolumeOpen) &&
        !OpenByFileId) {
 
        VolumeOpen = TRUE;
        CdAcquireVcbExclusive( IrpContext, Vcb, FALSE );
 
    } else {
 
        CdAcquireVcbShared( IrpContext, Vcb, FALSE );
    }
 
    //
    //  Use a try-finally to facilitate cleanup.
    //
 
    _SEH2_TRY {
 
        //
        //  Verify that the Vcb is not in an unusable condition.  This routine
        //  will raise if not usable.
        //
 
        CdVerifyVcb( IrpContext, Vcb );
 
        //
        //  If the Vcb is locked then we cannot open another file
        //
 
        if (FlagOn( Vcb->VcbState, VCB_STATE_LOCKED )) {
 
            try_return( Status = STATUS_ACCESS_DENIED );
        }
 
        //
        //  If we are opening this file by FileId then process this immediately
        //  and exit.
        //
 
        if (OpenByFileId) {
 
            //
            //  We only allow Dasd opens of audio disks.  Fail this request at
            //  this point.
            //
 
            if (FlagOn( Vcb->VcbState, VCB_STATE_AUDIO_DISK )) {
 
                try_return( Status = STATUS_INVALID_DEVICE_REQUEST );
            }
 
            //
            //  The only create disposition we allow is OPEN.
            //
 
            if ((CreateDisposition != FILE_OPEN) &&
                (CreateDisposition != FILE_OPEN_IF)) {
 
                try_return( Status = STATUS_ACCESS_DENIED );
            }
 
            //
            //  Make sure we can wait for this request.
            //
 
            if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
 
                CdRaiseStatus( IrpContext, STATUS_CANT_WAIT );
            }
 
            try_return( Status = CdOpenByFileId( IrpContext,
                                                 IrpSp,
                                                 Vcb,
                                                 &CurrentFcb ));
        }
 
        //
        //  If we are opening this volume Dasd then process this immediately
        //  and exit.
        //
 
        if (VolumeOpen) {
 
            //
            //  The only create disposition we allow is OPEN.
            //
 
            if ((CreateDisposition != FILE_OPEN) &&
                (CreateDisposition != FILE_OPEN_IF)) {
 
                try_return( Status = STATUS_ACCESS_DENIED );
            }
 
            //
            //  If they wanted to open a directory, surprise.
            //
 
            if (FlagOn( IrpSp->Parameters.Create.Options, FILE_DIRECTORY_FILE )) {
 
                try_return( Status = STATUS_NOT_A_DIRECTORY );
            }
 
            //
            //  Acquire the Fcb first.
            //
 
            CurrentFcb = Vcb->VolumeDasdFcb;
            CdAcquireFcbExclusive( IrpContext, CurrentFcb, FALSE );
 
            try_return( Status = CdOpenExistingFcb( IrpContext,
                                                    IrpSp,
                                                    &CurrentFcb,
                                                    UserVolumeOpen,
                                                    FALSE,
                                                    NULL ));
        }
 
        //
        //  At this point CurrentFcb points to the deepest Fcb for this open
        //  in the tree.  Let's acquire this Fcb to keep it from being deleted
        //  beneath us.
        //
 
        CdAcquireFcbExclusive( IrpContext, NextFcb, FALSE );
        CurrentFcb = NextFcb;
 
        //
        //  Do a prefix search if there is more of the name to parse.
        //
 
        if (RemainingName.FileName.Length != 0) {
 
            //
            //  Do the prefix search to find the longest matching name.
            //
 
            CdFindPrefix( IrpContext,
                          &CurrentFcb,
                          &RemainingName.FileName,
                          IgnoreCase );
        }
 
        //
        //  If the remaining name length is zero then we have found our
        //  target.
        //
 
        if (RemainingName.FileName.Length == 0) {
 
            //
            //  If this is a file so verify the user didn't want to open
            //  a directory.
            //
 
            if (SafeNodeType( CurrentFcb ) == CDFS_NTC_FCB_DATA) {
 
                if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TRAIL_BACKSLASH ) ||
                    FlagOn( IrpSp->Parameters.Create.Options, FILE_DIRECTORY_FILE )) {
 
                    try_return( Status = STATUS_NOT_A_DIRECTORY );
                }
 
                //
                //  The only create disposition we allow is OPEN.
                //
 
                if ((CreateDisposition != FILE_OPEN) &&
                    (CreateDisposition != FILE_OPEN_IF)) {
 
                    try_return( Status = STATUS_ACCESS_DENIED );
                }
 
                try_return( Status = CdOpenExistingFcb( IrpContext,
                                                        IrpSp,
                                                        &CurrentFcb,
                                                        UserFileOpen,
                                                        IgnoreCase,
                                                        RelatedCcb ));
 
            //
            //  This is a directory.  Verify the user didn't want to open
            //  as a file.
            //
 
            } else if (FlagOn( IrpSp->Parameters.Create.Options, FILE_NON_DIRECTORY_FILE )) {
 
                try_return( Status = STATUS_FILE_IS_A_DIRECTORY );
 
            //
            //  Open the file as a directory.
            //
 
            } else {
 
                //
                //  The only create disposition we allow is OPEN.
                //
 
                if ((CreateDisposition != FILE_OPEN) &&
                    (CreateDisposition != FILE_OPEN_IF)) {
 
                    try_return( Status = STATUS_ACCESS_DENIED );
                }
 
                try_return( Status = CdOpenExistingFcb( IrpContext,
                                                        IrpSp,
                                                        &CurrentFcb,
                                                        UserDirectoryOpen,
                                                        IgnoreCase,
                                                        RelatedCcb ));
            }
        }
 
        //
        //  We have more work to do.  We have a starting Fcb which we own shared.
        //  We also have the remaining name to parse.  Walk through the name
        //  component by component looking for the full name.
        //
 
        //
        //  Our starting Fcb better be a directory.
        //
 
        if (!FlagOn( CurrentFcb->FileAttributes, FILE_ATTRIBUTE_DIRECTORY )) {
 
            try_return( Status = STATUS_OBJECT_PATH_NOT_FOUND );
        }
 
        //
        //  If we can't wait then post this request.
        //
 
        if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
 
            CdRaiseStatus( IrpContext, STATUS_CANT_WAIT );
        }
 
        //
        //  Make sure the final name has no version string.
        //
 
        FinalName.VersionString.Length = 0;
 
        while (TRUE) {
 
            ShortNameMatch = FALSE;
 
            //
            //  Split off the next component from the name.
            //
 
            CdDissectName( IrpContext,
                           &RemainingName.FileName,
                           &FinalName.FileName );
 
            //
            //  Go ahead and look this entry up in the path table.
            //
 
            CdInitializeCompoundPathEntry( IrpContext, &CompoundPathEntry );
            CleanupCompoundPathEntry = TRUE;
 
            FoundEntry = CdFindPathEntry( IrpContext,
                                          CurrentFcb,
                                          &FinalName,
                                          IgnoreCase,
                                          &CompoundPathEntry );
 
            //
            //  If we didn't find the entry then check if the current name
            //  is a possible short name.
            //
 
            if (!FoundEntry) {
 
                ShortNameDirentOffset = CdShortNameDirentOffset( IrpContext, &FinalName.FileName );
 
                //
                //  If there is an embedded short name offset then look for the
                //  matching long name in the directory.
                //
 
                if (ShortNameDirentOffset != MAXULONG) {
 
                    if (CleanupFileContext) {
 
                        CdCleanupFileContext( IrpContext, &FileContext );
                    }
 
                    CdInitializeFileContext( IrpContext, &FileContext );
                    CleanupFileContext = TRUE;
 
                    FoundEntry = CdFindFileByShortName( IrpContext,
                                                        CurrentFcb,
                                                        &FinalName,
                                                        IgnoreCase,
                                                        ShortNameDirentOffset,
                                                        &FileContext );
 
                    //
                    //  If we found an entry and it is a directory then look
                    //  this up in the path table.
                    //
 
                    if (FoundEntry) {
 
                        ShortNameMatch = TRUE;
 
                        if (FlagOn( FileContext.InitialDirent->Dirent.DirentFlags,
                                    CD_ATTRIBUTE_DIRECTORY )) {
 
                            CdCleanupCompoundPathEntry( IrpContext, &CompoundPathEntry );
                            CdInitializeCompoundPathEntry( IrpContext, &CompoundPathEntry );
 
                            FoundEntry = CdFindPathEntry( IrpContext,
                                                          CurrentFcb,
                                                          &FileContext.InitialDirent->Dirent.CdCaseFileName,
                                                          IgnoreCase,
                                                          &CompoundPathEntry );
 
                            //
                            //  We better find this entry.
                            //
 
                            if (!FoundEntry) {
 
                                CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
                            }
 
                            //
                            //  Upcase the name with the short name if case
                            //  insensitive.
                            //
 
                            if (IgnoreCase) {
 
                                CdUpcaseName( IrpContext, &FinalName, &FinalName );
                            }
 
                        //
                        //  We found a matching file.  If we are at the last
                        //  entry then break out of the loop and open the
                        //  file below.  Otherwise we return an error.
                        //
 
                        } else if (RemainingName.FileName.Length == 0) {
 
                            //
                            //  Break out of the loop.  We will process the dirent
                            //  below.
                            //
 
                            MatchingName = &FileContext.ShortName;
                            break;
 
                        } else {
 
                            try_return( Status = STATUS_OBJECT_PATH_NOT_FOUND );
                        }
                    }
                }
 
                //
                //  We didn't find the name in either the path table or as
                //  a short name in a directory.  If the remaining name
                //  length is zero then break out of the loop to search
                //  the directory.
                //
 
                if (!FoundEntry) {
 
                    if (RemainingName.FileName.Length == 0) {
 
                        break;
 
                    //
                    //  Otherwise this path could not be cracked.
                    //
 
                    } else {
 
                        try_return( Status = STATUS_OBJECT_PATH_NOT_FOUND );
                    }
                }
            }
 
            //
            //  If this is an ignore case open then copy the exact case
            //  in the file object name.  If it was a short name match then
            //  the name must be upcase already.
            //
 
            if (IgnoreCase && !ShortNameMatch) {
 
                RtlCopyMemory( FinalName.FileName.Buffer,
                               CompoundPathEntry.PathEntry.CdDirName.FileName.Buffer,
                               CompoundPathEntry.PathEntry.CdDirName.FileName.Length );
            }
 
            //
            //  If we have found the last component then open this as a directory
            //  and return to our caller.
            //
 
            if (RemainingName.FileName.Length == 0) {
 
                if (FlagOn( IrpSp->Parameters.Create.Options, FILE_NON_DIRECTORY_FILE )) {
 
                    try_return( Status = STATUS_FILE_IS_A_DIRECTORY );
                }
 
                //
                //  The only create disposition we allow is OPEN.
                //
 
                if ((CreateDisposition != FILE_OPEN) &&
                    (CreateDisposition != FILE_OPEN_IF)) {
 
                    try_return( Status = STATUS_ACCESS_DENIED );
                }
 
                try_return( Status = CdOpenDirectoryFromPathEntry( IrpContext,
                                                                   IrpSp,
                                                                   Vcb,
                                                                   &CurrentFcb,
                                                                   &FinalName,
                                                                   IgnoreCase,
                                                                   ShortNameMatch,
                                                                   &CompoundPathEntry.PathEntry,
                                                                   TRUE,
                                                                   RelatedCcb ));
            }
 
            //
            //  Otherwise open an Fcb for this intermediate index Fcb.
            //
 
            CdOpenDirectoryFromPathEntry( IrpContext,
                                          IrpSp,
                                          Vcb,
                                          &CurrentFcb,
                                          &FinalName,
                                          IgnoreCase,
                                          ShortNameMatch,
                                          &CompoundPathEntry.PathEntry,
                                          FALSE,
                                          NULL );
 
            CdCleanupCompoundPathEntry( IrpContext, &CompoundPathEntry );
            CleanupCompoundPathEntry = FALSE;
        }
 
        //
        //  We need to scan the current directory for a matching file name
        //  if we don't already have one.
        //
 
        if (!FoundEntry) {
 
            if (CleanupFileContext) {
 
                CdCleanupFileContext( IrpContext, &FileContext );
            }
 
            CdInitializeFileContext( IrpContext, &FileContext );
            CleanupFileContext = TRUE;
 
            //
            //  Split our search name into separate components.
            //
 
            CdConvertNameToCdName( IrpContext, &FinalName );
 
            FoundEntry = CdFindFile( IrpContext,
                                     CurrentFcb,
                                     &FinalName,
                                     IgnoreCase,
                                     &FileContext,
                                     &MatchingName );
        }
 
        //
        //  If we didn't find a match then check if the name is invalid to
        //  determine which error code to return.
        //
 
        if (!FoundEntry) {
 
            if ((CreateDisposition == FILE_OPEN) ||
                (CreateDisposition == FILE_OVERWRITE)) {
 
                try_return( Status = STATUS_OBJECT_NAME_NOT_FOUND );
            }
 
            //
            //  Any other operation return STATUS_ACCESS_DENIED.
            //
 
            try_return( Status = STATUS_ACCESS_DENIED );
        }
 
        //
        //  If this is a directory then the disk is corrupt because it wasn't
        //  in the Path Table.
        //
 
        if (FlagOn( FileContext.InitialDirent->Dirent.Flags, CD_ATTRIBUTE_DIRECTORY )) {
 
            CdRaiseStatus( IrpContext, STATUS_DISK_CORRUPT_ERROR );
        }
 
        //
        //  Make sure our opener didn't want a directory.
        //
 
        if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TRAIL_BACKSLASH ) ||
            FlagOn( IrpSp->Parameters.Create.Options, FILE_DIRECTORY_FILE )) {
 
            try_return( Status = STATUS_NOT_A_DIRECTORY );
        }
 
        //
        //  The only create disposition we allow is OPEN.
        //
 
        if ((CreateDisposition != FILE_OPEN) &&
            (CreateDisposition != FILE_OPEN_IF)) {
 
            try_return( Status = STATUS_ACCESS_DENIED );
        }
 
        //
        //  If this is an ignore case open then copy the exact case
        //  in the file object name.  Any version portion should
        //  already be upcased.
        //
 
        if (IgnoreCase) {
 
            RtlCopyMemory( FinalName.FileName.Buffer,
                           MatchingName->FileName.Buffer,
                           MatchingName->FileName.Length );
        }
 
        //
        //  Open the file using the file context.  We already have the
        //  first and last dirents.
        //
 
        try_return( Status = CdOpenFileFromFileContext( IrpContext,
                                                        IrpSp,
                                                        Vcb,
                                                        &CurrentFcb,
                                                        &FinalName,
                                                        IgnoreCase,
                                                        (BOOLEAN) (MatchingName == &FileContext.ShortName),
                                                        &FileContext,
                                                        RelatedCcb ));
 
    try_exit:  NOTHING;
    } _SEH2_FINALLY {
 
        //
        //  Cleanup the PathEntry if initialized.
        //
 
        if (CleanupCompoundPathEntry) {
 
            CdCleanupCompoundPathEntry( IrpContext, &CompoundPathEntry );
        }
 
        //
        //  Cleanup the FileContext if initialized.
        //
 
        if (CleanupFileContext) {
 
            CdCleanupFileContext( IrpContext, &FileContext );
        }
 
        //
        //  The result of this open could be success, pending or some error
        //  condition.
        //
 
        if (_SEH2_AbnormalTermination()) {
 
 
            //
            //  In the error path we start by calling our teardown routine if we
            //  have a CurrentFcb and its not the volume Dasd Fcb.
            //
 
            if ((CurrentFcb != NULL) &&
                (CurrentFcb != Vcb->VolumeDasdFcb)) {
 
                BOOLEAN RemovedFcb;
 
                CdTeardownStructures( IrpContext, CurrentFcb, &RemovedFcb );
 
                if (RemovedFcb) {
 
                    CurrentFcb = NULL;
                }
            }
 
            //
            //  No need to complete the request.
            //
 
            IrpContext = NULL;
            Irp = NULL;
 
        //
        //  If we posted this request through the oplock package we need
        //  to show that there is no reason to complete the request.
        //
 
        } else if (Status == STATUS_PENDING) {
 
            IrpContext = NULL;
            Irp = NULL;
        }
 
        //
        //  Release the Current Fcb if still acquired.
        //
 
        if (CurrentFcb != NULL) {
            _Analysis_assume_lock_held_(CurrentFcb->FcbNonpaged->FcbResource);
            CdReleaseFcb( IrpContext, CurrentFcb );
        }
 
        //
        //  Release the Vcb.
        //
 
        CdReleaseVcb( IrpContext, Vcb );
 
        //
        //  Call our completion routine.  It will handle the case where either
        //  the Irp and/or IrpContext are gone.
        //
 
        CdCompleteRequest( IrpContext, Irp, Status );
    } _SEH2_END;
 
    return Status;
}