mirror of
https://github.com/reactos/reactos.git
synced 2024-09-01 08:14:01 +00:00
2973 lines
86 KiB
C
2973 lines
86 KiB
C
/*++
|
||
|
||
Copyright (c) 1989-2000 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
Create.c
|
||
|
||
Abstract:
|
||
|
||
This module implements the File Create routine for Cdfs called by the
|
||
Fsd/Fsp dispatch routines.
|
||
|
||
|
||
--*/
|
||
|
||
#include "cdprocs.h"
|
||
|
||
//
|
||
// The Bug check file id for this module
|
||
//
|
||
|
||
#define BugCheckFileId (CDFS_BUG_CHECK_CREATE)
|
||
|
||
//
|
||
// Local support routines
|
||
//
|
||
|
||
_When_(RelatedTypeOfOpen != UnopenedFileObject, _At_(RelatedCcb, _In_))
|
||
_When_(RelatedTypeOfOpen == UnopenedFileObject, _At_(RelatedCcb, _In_opt_))
|
||
_When_(RelatedTypeOfOpen != UnopenedFileObject, _At_(RelatedFileName, _In_))
|
||
_When_(RelatedTypeOfOpen == UnopenedFileObject, _At_(RelatedFileName, _In_opt_))
|
||
NTSTATUS
|
||
CdNormalizeFileNames (
|
||
_Inout_ PIRP_CONTEXT IrpContext,
|
||
_In_ PVCB Vcb,
|
||
_In_ BOOLEAN OpenByFileId,
|
||
_In_ BOOLEAN IgnoreCase,
|
||
_In_ TYPE_OF_OPEN RelatedTypeOfOpen,
|
||
PCCB RelatedCcb,
|
||
PUNICODE_STRING RelatedFileName,
|
||
_Inout_ PUNICODE_STRING FileName,
|
||
_Inout_ PCD_NAME RemainingName
|
||
);
|
||
|
||
_Requires_lock_held_(_Global_critical_region_)
|
||
_Acquires_exclusive_lock_((*CurrentFcb)->FcbNonpaged->FcbResource)
|
||
NTSTATUS
|
||
CdOpenByFileId (
|
||
_In_ PIRP_CONTEXT IrpContext,
|
||
_In_ PIO_STACK_LOCATION IrpSp,
|
||
_In_ PVCB Vcb,
|
||
_Inout_ PFCB *CurrentFcb
|
||
);
|
||
|
||
_Requires_lock_held_(_Global_critical_region_)
|
||
NTSTATUS
|
||
CdOpenExistingFcb (
|
||
_In_ PIRP_CONTEXT IrpContext,
|
||
_In_ PIO_STACK_LOCATION IrpSp,
|
||
_Inout_ PFCB *CurrentFcb,
|
||
_In_ TYPE_OF_OPEN TypeOfOpen,
|
||
_In_ BOOLEAN IgnoreCase,
|
||
_In_opt_ PCCB RelatedCcb
|
||
);
|
||
|
||
_Requires_lock_held_(_Global_critical_region_)
|
||
_Acquires_lock_((*CurrentFcb)->FcbNonpaged->FcbResource)
|
||
NTSTATUS
|
||
CdOpenDirectoryFromPathEntry (
|
||
_In_ PIRP_CONTEXT IrpContext,
|
||
_In_ PIO_STACK_LOCATION IrpSp,
|
||
_In_ PVCB Vcb,
|
||
_Inout_ PFCB *CurrentFcb,
|
||
_In_ PCD_NAME DirName,
|
||
_In_ BOOLEAN IgnoreCase,
|
||
_In_ BOOLEAN ShortNameMatch,
|
||
_In_ PPATH_ENTRY PathEntry,
|
||
_In_ BOOLEAN PerformUserOpen,
|
||
_In_opt_ PCCB RelatedCcb
|
||
);
|
||
|
||
_Requires_lock_held_(_Global_critical_region_)
|
||
NTSTATUS
|
||
CdOpenFileFromFileContext (
|
||
_In_ PIRP_CONTEXT IrpContext,
|
||
_In_ PIO_STACK_LOCATION IrpSp,
|
||
_In_ PVCB Vcb,
|
||
_Inout_ PFCB *CurrentFcb,
|
||
_In_ PCD_NAME FileName,
|
||
_In_ BOOLEAN IgnoreCase,
|
||
_In_ BOOLEAN ShortNameMatch,
|
||
_In_ PFILE_ENUM_CONTEXT FileContext,
|
||
_In_opt_ PCCB RelatedCcb
|
||
);
|
||
|
||
_Requires_lock_held_(_Global_critical_region_)
|
||
NTSTATUS
|
||
CdCompleteFcbOpen (
|
||
_In_ PIRP_CONTEXT IrpContext,
|
||
_In_ PIO_STACK_LOCATION IrpSp,
|
||
_In_ PVCB Vcb,
|
||
_Inout_ PFCB *CurrentFcb,
|
||
_In_ TYPE_OF_OPEN TypeOfOpen,
|
||
_In_ ULONG UserCcbFlags,
|
||
_In_ ACCESS_MASK DesiredAccess
|
||
);
|
||
|
||
#ifdef ALLOC_PRAGMA
|
||
#pragma alloc_text(PAGE, CdCommonCreate)
|
||
#pragma alloc_text(PAGE, CdCompleteFcbOpen)
|
||
#pragma alloc_text(PAGE, CdNormalizeFileNames)
|
||
#pragma alloc_text(PAGE, CdOpenByFileId)
|
||
#pragma alloc_text(PAGE, CdOpenDirectoryFromPathEntry)
|
||
#pragma alloc_text(PAGE, CdOpenExistingFcb)
|
||
#pragma alloc_text(PAGE, CdOpenFileFromFileContext)
|
||
#endif
|
||
|
||
|
||
_Requires_lock_held_(_Global_critical_region_)
|
||
NTSTATUS
|
||
#ifdef _MSC_VER
|
||
#pragma prefast(suppress: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;
|
||
}
|
||
|
||
|
||
//
|
||
// Local support routine
|
||
//
|
||
_When_(RelatedTypeOfOpen != UnopenedFileObject, _At_(RelatedCcb, _In_))
|
||
_When_(RelatedTypeOfOpen == UnopenedFileObject, _At_(RelatedCcb, _In_opt_))
|
||
_When_(RelatedTypeOfOpen != UnopenedFileObject, _At_(RelatedFileName, _In_))
|
||
_When_(RelatedTypeOfOpen == UnopenedFileObject, _At_(RelatedFileName, _In_opt_))
|
||
NTSTATUS
|
||
CdNormalizeFileNames (
|
||
_Inout_ PIRP_CONTEXT IrpContext,
|
||
_In_ PVCB Vcb,
|
||
_In_ BOOLEAN OpenByFileId,
|
||
_In_ BOOLEAN IgnoreCase,
|
||
_In_ TYPE_OF_OPEN RelatedTypeOfOpen,
|
||
PCCB RelatedCcb,
|
||
PUNICODE_STRING RelatedFileName,
|
||
_Inout_ PUNICODE_STRING FileName,
|
||
_Inout_ PCD_NAME RemainingName
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to store the full name and upcased name into the
|
||
filename buffer. We only upcase the portion yet to parse. We also
|
||
check for a trailing backslash and lead-in double backslashes. This
|
||
routine also verifies the mode of the related open against the name
|
||
currently in the filename.
|
||
|
||
Arguments:
|
||
|
||
Vcb - Vcb for this volume.
|
||
|
||
OpenByFileId - Indicates if the filename should be a 64 bit FileId.
|
||
|
||
IgnoreCase - Indicates if this open is a case-insensitive operation.
|
||
|
||
RelatedTypeOfOpen - Indicates the type of the related file object.
|
||
|
||
RelatedCcb - Ccb for the related open. Ignored if no relative open.
|
||
|
||
RelatedFileName - FileName buffer for related open. Ignored if no
|
||
relative open.
|
||
|
||
FileName - FileName to update in this routine. The name should
|
||
either be a 64-bit FileId or a Unicode string.
|
||
|
||
RemainingName - Name with the remaining portion of the name. This
|
||
will begin after the related name and any separator. For a
|
||
non-relative open we also step over the initial separator.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - STATUS_SUCCESS if the names are OK, appropriate error code
|
||
otherwise.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG RemainingNameLength = 0;
|
||
ULONG RelatedNameLength = 0;
|
||
ULONG SeparatorLength = 0;
|
||
|
||
ULONG BufferLength;
|
||
|
||
UNICODE_STRING NewFileName;
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// If this is the first pass then we need to build the full name and
|
||
// check for name compatibility.
|
||
//
|
||
|
||
if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_FULL_NAME )) {
|
||
|
||
//
|
||
// Deal with the regular file name case first.
|
||
//
|
||
|
||
if (!OpenByFileId) {
|
||
|
||
//
|
||
// This is here because the Win32 layer can't avoid sending me double
|
||
// beginning backslashes.
|
||
//
|
||
|
||
if ((FileName->Length > sizeof( WCHAR )) &&
|
||
(FileName->Buffer[1] == L'\\') &&
|
||
(FileName->Buffer[0] == L'\\')) {
|
||
|
||
//
|
||
// If there are still two beginning backslashes, the name is bogus.
|
||
//
|
||
|
||
if ((FileName->Length > 2 * sizeof( WCHAR )) &&
|
||
(FileName->Buffer[2] == L'\\')) {
|
||
|
||
return STATUS_OBJECT_NAME_INVALID;
|
||
}
|
||
|
||
//
|
||
// Slide the name down in the buffer.
|
||
//
|
||
|
||
FileName->Length -= sizeof( WCHAR );
|
||
|
||
RtlMoveMemory( FileName->Buffer,
|
||
FileName->Buffer + 1,
|
||
FileName->Length );
|
||
}
|
||
|
||
//
|
||
// Check for a trailing backslash. Don't strip off if only character
|
||
// in the full name or for relative opens where this is illegal.
|
||
//
|
||
|
||
if (((FileName->Length > sizeof( WCHAR)) ||
|
||
((FileName->Length == sizeof( WCHAR )) && (RelatedTypeOfOpen == UserDirectoryOpen))) &&
|
||
(FileName->Buffer[ (FileName->Length/2) - 1 ] == L'\\')) {
|
||
|
||
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_TRAIL_BACKSLASH );
|
||
FileName->Length -= sizeof( WCHAR );
|
||
}
|
||
|
||
//
|
||
// Remember the length we need for this portion of the name.
|
||
//
|
||
|
||
RemainingNameLength = FileName->Length;
|
||
|
||
//
|
||
// If this is a related file object then we verify the compatibility
|
||
// of the name in the file object with the relative file object.
|
||
//
|
||
|
||
if (RelatedTypeOfOpen != UnopenedFileObject) {
|
||
|
||
//
|
||
// If the filename length was zero then it must be legal.
|
||
// If there are characters then check with the related
|
||
// type of open.
|
||
//
|
||
|
||
if (FileName->Length != 0) {
|
||
|
||
//
|
||
// The name length must always be zero for a volume open.
|
||
//
|
||
|
||
if (RelatedTypeOfOpen <= UserVolumeOpen) {
|
||
|
||
return STATUS_INVALID_PARAMETER;
|
||
|
||
//
|
||
// The remaining name cannot begin with a backslash.
|
||
//
|
||
|
||
} else if (FileName->Buffer[0] == L'\\' ) {
|
||
|
||
return STATUS_INVALID_PARAMETER;
|
||
|
||
//
|
||
// If the related file is a user file then there
|
||
// is no file with this path.
|
||
//
|
||
|
||
} else if (RelatedTypeOfOpen == UserFileOpen) {
|
||
|
||
return STATUS_OBJECT_PATH_NOT_FOUND;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Remember the length of the related name when building
|
||
// the full name. We leave the RelatedNameLength and
|
||
// SeparatorLength at zero if the relative file is opened
|
||
// by Id.
|
||
//
|
||
|
||
if (!FlagOn( RelatedCcb->Flags, CCB_FLAG_OPEN_BY_ID )) {
|
||
|
||
//
|
||
// Add a separator if the name length is non-zero
|
||
// unless the relative Fcb is at the root.
|
||
//
|
||
|
||
if ((FileName->Length != 0) &&
|
||
(RelatedCcb->Fcb != Vcb->RootIndexFcb)) {
|
||
|
||
SeparatorLength = sizeof( WCHAR );
|
||
}
|
||
|
||
RelatedNameLength = RelatedFileName->Length;
|
||
}
|
||
|
||
//
|
||
// The full name is already in the filename. It must either
|
||
// be length 0 or begin with a backslash.
|
||
//
|
||
|
||
} else if (FileName->Length != 0) {
|
||
|
||
if (FileName->Buffer[0] != L'\\') {
|
||
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
//
|
||
// We will want to trim the leading backslash from the
|
||
// remaining name we return.
|
||
//
|
||
|
||
RemainingNameLength -= sizeof( WCHAR );
|
||
SeparatorLength = sizeof( WCHAR );
|
||
}
|
||
|
||
//
|
||
// Now see if the buffer is large enough to hold the full name.
|
||
//
|
||
|
||
BufferLength = RelatedNameLength + SeparatorLength + RemainingNameLength;
|
||
|
||
//
|
||
// Check for an overflow of the maximum filename size.
|
||
//
|
||
|
||
if (BufferLength > MAXUSHORT) {
|
||
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
//
|
||
// Now see if we need to allocate a new buffer.
|
||
//
|
||
|
||
if (FileName->MaximumLength < BufferLength) {
|
||
|
||
NewFileName.Buffer = FsRtlAllocatePoolWithTag( CdPagedPool,
|
||
BufferLength,
|
||
TAG_FILE_NAME );
|
||
|
||
NewFileName.MaximumLength = (USHORT) BufferLength;
|
||
|
||
} else {
|
||
|
||
NewFileName.Buffer = FileName->Buffer;
|
||
NewFileName.MaximumLength = FileName->MaximumLength;
|
||
}
|
||
|
||
//
|
||
// If there is a related name then we need to slide the remaining bytes up and
|
||
// insert the related name. Otherwise the name is in the correct position
|
||
// already.
|
||
//
|
||
|
||
if (RelatedNameLength != 0) {
|
||
|
||
//
|
||
// Store the remaining name in its correct position.
|
||
//
|
||
|
||
if (RemainingNameLength != 0) {
|
||
|
||
RtlMoveMemory( Add2Ptr( NewFileName.Buffer, RelatedNameLength + SeparatorLength, PVOID ),
|
||
FileName->Buffer,
|
||
RemainingNameLength );
|
||
}
|
||
|
||
RtlCopyMemory( NewFileName.Buffer,
|
||
RelatedFileName->Buffer,
|
||
RelatedNameLength );
|
||
|
||
//
|
||
// Add the separator if needed.
|
||
//
|
||
|
||
if (SeparatorLength != 0) {
|
||
|
||
*(Add2Ptr( NewFileName.Buffer, RelatedNameLength, PWCHAR )) = L'\\';
|
||
}
|
||
|
||
//
|
||
// Update the filename value we got from the user.
|
||
//
|
||
|
||
if (NewFileName.Buffer != FileName->Buffer) {
|
||
|
||
if (FileName->Buffer != NULL) {
|
||
|
||
CdFreePool( &FileName->Buffer );
|
||
}
|
||
|
||
FileName->Buffer = NewFileName.Buffer;
|
||
FileName->MaximumLength = NewFileName.MaximumLength;
|
||
}
|
||
|
||
//
|
||
// Copy the name length to the user's filename.
|
||
//
|
||
|
||
FileName->Length = (USHORT) (RelatedNameLength + SeparatorLength + RemainingNameLength);
|
||
}
|
||
|
||
//
|
||
// Now update the remaining name to parse.
|
||
//
|
||
|
||
RemainingName->FileName.MaximumLength =
|
||
RemainingName->FileName.Length = (USHORT) RemainingNameLength;
|
||
RemainingName->VersionString.Length = 0;
|
||
|
||
RemainingName->FileName.Buffer = Add2Ptr( FileName->Buffer,
|
||
RelatedNameLength + SeparatorLength,
|
||
PWCHAR );
|
||
|
||
//
|
||
// Upcase the name if necessary.
|
||
//
|
||
|
||
if (IgnoreCase && (RemainingNameLength != 0)) {
|
||
|
||
CdUpcaseName( IrpContext,
|
||
RemainingName,
|
||
RemainingName );
|
||
}
|
||
|
||
//
|
||
// Do a quick check to make sure there are no wildcards.
|
||
//
|
||
#ifdef _MSC_VER
|
||
#pragma prefast(push)
|
||
#pragma prefast(suppress:26000, "RemainingName->FileName.Buffer = FileName.Buffer + (RelatedNameLength + SeparatorLength); FileName.MaximumLength < (RelatedNameLength + SeparatorLength + RemainingNameLength).")
|
||
#endif
|
||
if (FsRtlDoesNameContainWildCards( &RemainingName->FileName )) {
|
||
#ifdef _MSC_VER
|
||
#pragma prefast(pop)
|
||
#endif
|
||
|
||
return STATUS_OBJECT_NAME_INVALID;
|
||
}
|
||
|
||
//
|
||
// For the open by file Id case we verify the name really contains
|
||
// a 64 bit value.
|
||
//
|
||
|
||
} else {
|
||
|
||
//
|
||
// Check for validity of the buffer.
|
||
//
|
||
|
||
if (FileName->Length != sizeof( FILE_ID )) {
|
||
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
}
|
||
|
||
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_FULL_NAME );
|
||
|
||
//
|
||
// If we are in the retry path then the full name is already in the
|
||
// file object name. If this is a case-sensitive operation then
|
||
// we need to upcase the name from the end of any related file name already stored
|
||
// there.
|
||
//
|
||
|
||
} else {
|
||
|
||
//
|
||
// Assume there is no relative name.
|
||
//
|
||
|
||
RemainingName->FileName = *FileName;
|
||
RemainingName->VersionString.Length = 0;
|
||
|
||
//
|
||
// Nothing to do if the name length is zero.
|
||
//
|
||
|
||
if (RemainingName->FileName.Length != 0) {
|
||
|
||
//
|
||
// If there is a relative name then we need to walk past it.
|
||
//
|
||
|
||
if (RelatedTypeOfOpen != UnopenedFileObject) {
|
||
|
||
//
|
||
// Nothing to walk past if the RelatedCcb is opened by FileId.
|
||
//
|
||
|
||
|
||
if (!FlagOn( RelatedCcb->Flags, CCB_FLAG_OPEN_BY_ID )) {
|
||
|
||
//
|
||
// Related file name is a proper prefix of the full name.
|
||
// We step over the related name and if we are then
|
||
// pointing at a separator character we step over that.
|
||
//
|
||
|
||
RemainingName->FileName.Buffer = Add2Ptr( RemainingName->FileName.Buffer,
|
||
RelatedFileName->Length,
|
||
PWCHAR );
|
||
|
||
RemainingName->FileName.Length -= RelatedFileName->Length;
|
||
}
|
||
}
|
||
|
||
//
|
||
// If we are pointing at a separator character then step past that.
|
||
//
|
||
|
||
if (RemainingName->FileName.Length != 0) {
|
||
|
||
if (*(RemainingName->FileName.Buffer) == L'\\') {
|
||
|
||
RemainingName->FileName.Buffer = Add2Ptr( RemainingName->FileName.Buffer,
|
||
sizeof( WCHAR ),
|
||
PWCHAR );
|
||
|
||
RemainingName->FileName.Length -= sizeof( WCHAR );
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// Upcase the name if necessary.
|
||
//
|
||
|
||
if (IgnoreCase && (RemainingName->FileName.Length != 0)) {
|
||
|
||
CdUpcaseName( IrpContext,
|
||
RemainingName,
|
||
RemainingName );
|
||
}
|
||
}
|
||
|
||
#ifdef _MSC_VER
|
||
#pragma prefast(push)
|
||
#pragma prefast(suppress:26030, "RemainingName->FileName.Buffer = FileName.Buffer + (RelatedNameLength + SeparatorLength); FileName.MaximumLength < (RelatedNameLength + SeparatorLength + RemainingNameLength).")
|
||
#endif
|
||
return STATUS_SUCCESS;
|
||
#ifdef _MSC_VER
|
||
#pragma prefast(pop)
|
||
#endif
|
||
}
|
||
|
||
|
||
//
|
||
// Local support routine
|
||
//
|
||
|
||
_Requires_lock_held_(_Global_critical_region_)
|
||
_Acquires_exclusive_lock_((*CurrentFcb)->FcbNonpaged->FcbResource)
|
||
NTSTATUS
|
||
CdOpenByFileId (
|
||
_In_ PIRP_CONTEXT IrpContext,
|
||
_In_ PIO_STACK_LOCATION IrpSp,
|
||
_In_ PVCB Vcb,
|
||
_Inout_ PFCB *CurrentFcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to open a file by the FileId. The file Id is in
|
||
the FileObject name buffer and has been verified to be 64 bits.
|
||
|
||
We extract the Id number and then check to see whether we are opening a
|
||
file or directory and compare that with the create options. If this
|
||
generates no error then optimistically look up the Fcb in the Fcb Table.
|
||
|
||
If we don't find the Fcb then we need to carefully verify there is a file
|
||
at this offset. First check whether the Parent Fcb is in the table. If
|
||
not then lookup the parent at the path table offset given by file ID.
|
||
|
||
If found then build the Fcb from this entry and store the new Fcb in the
|
||
tree.
|
||
|
||
We know have the parent Fcb. Do a directory scan to find the dirent at
|
||
the given offset in this stream. This must point to the first entry
|
||
of a valid file.
|
||
|
||
Finally we call our worker routine to complete the open on this Fcb.
|
||
|
||
Arguments:
|
||
|
||
IrpSp - Stack location within the create Irp.
|
||
|
||
Vcb - Vcb for this volume.
|
||
|
||
CurrentFcb - Address to store the Fcb for this open. We only store the
|
||
CurrentFcb here when we have acquired it so our caller knows to
|
||
free or deallocate it.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Status indicating the result of the operation.
|
||
|
||
--*/
|
||
|
||
{
|
||
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;
|
||
}
|
||
|
||
|
||
//
|
||
// Local support routine
|
||
//
|
||
|
||
_Requires_lock_held_(_Global_critical_region_)
|
||
NTSTATUS
|
||
CdOpenExistingFcb (
|
||
_In_ PIRP_CONTEXT IrpContext,
|
||
_In_ PIO_STACK_LOCATION IrpSp,
|
||
_Inout_ PFCB *CurrentFcb,
|
||
_In_ TYPE_OF_OPEN TypeOfOpen,
|
||
_In_ BOOLEAN IgnoreCase,
|
||
_In_opt_ PCCB RelatedCcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to open an Fcb which is already in the Fcb table.
|
||
We will verify the access to the file and then call our worker routine
|
||
to perform the final operations.
|
||
|
||
Arguments:
|
||
|
||
IrpSp - Pointer to the stack location for this open.
|
||
|
||
CurrentFcb - Address of Fcb to open. We will clear this if the Fcb
|
||
is released here.
|
||
|
||
TypeOfOpen - Indicates whether we are opening a file, directory or volume.
|
||
|
||
IgnoreCase - Indicates if this open is case-insensitive.
|
||
|
||
RelatedCcb - Ccb for related file object if relative open. We use
|
||
this when setting the Ccb flags for this open. It will tell
|
||
us whether the name currently in the file object is relative or
|
||
absolute.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Status indicating the result of the operation.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG CcbFlags = 0;
|
||
|
||
NTSTATUS Status = STATUS_ACCESS_DENIED;
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Check that the desired access is legal.
|
||
//
|
||
|
||
if (!CdIllegalFcbAccess( IrpContext,
|
||
TypeOfOpen,
|
||
IrpSp->Parameters.Create.SecurityContext->DesiredAccess )) {
|
||
|
||
//
|
||
// Set the Ignore case.
|
||
//
|
||
|
||
if (IgnoreCase) {
|
||
|
||
SetFlag( CcbFlags, CCB_FLAG_IGNORE_CASE );
|
||
}
|
||
|
||
//
|
||
// Check the related Ccb to see if this was an OpenByFileId and
|
||
// whether there was a version.
|
||
//
|
||
|
||
if (ARGUMENT_PRESENT( RelatedCcb )) {
|
||
|
||
SetFlag( CcbFlags, FlagOn( RelatedCcb->Flags, CCB_FLAG_OPEN_WITH_VERSION ));
|
||
|
||
|
||
if (FlagOn( RelatedCcb->Flags, CCB_FLAG_OPEN_BY_ID | CCB_FLAG_OPEN_RELATIVE_BY_ID )) {
|
||
|
||
SetFlag( CcbFlags, CCB_FLAG_OPEN_RELATIVE_BY_ID );
|
||
}
|
||
}
|
||
|
||
//
|
||
// Call our worker routine to complete the open.
|
||
//
|
||
|
||
Status = CdCompleteFcbOpen( IrpContext,
|
||
IrpSp,
|
||
(*CurrentFcb)->Vcb,
|
||
CurrentFcb,
|
||
TypeOfOpen,
|
||
CcbFlags,
|
||
IrpSp->Parameters.Create.SecurityContext->DesiredAccess );
|
||
}
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
//
|
||
// Local support routine
|
||
//
|
||
|
||
_Requires_lock_held_(_Global_critical_region_)
|
||
_Acquires_lock_((*CurrentFcb)->FcbNonpaged->FcbResource)
|
||
NTSTATUS
|
||
CdOpenDirectoryFromPathEntry (
|
||
_In_ PIRP_CONTEXT IrpContext,
|
||
_In_ PIO_STACK_LOCATION IrpSp,
|
||
_In_ PVCB Vcb,
|
||
_Inout_ PFCB *CurrentFcb,
|
||
_In_ PCD_NAME DirName,
|
||
_In_ BOOLEAN IgnoreCase,
|
||
_In_ BOOLEAN ShortNameMatch,
|
||
_In_ PPATH_ENTRY PathEntry,
|
||
_In_ BOOLEAN PerformUserOpen,
|
||
_In_opt_ PCCB RelatedCcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to open a directory where the directory was found
|
||
in the path table. This routine is called in the case where this is the
|
||
file to open for the user and where this is an intermediate node in the
|
||
full path to open.
|
||
|
||
We first check that the desired access is legal for a directory. Then we
|
||
construct the FileId for this and do a check to see if it is the Fcb
|
||
Table. It is always possible that either it was created since or simply
|
||
wasn't in the prefix table at the time of the prefix table search.
|
||
Initialize the Fcb and store into the FcbTable if not present.
|
||
|
||
Next we will add this to the prefix table of our parent if needed.
|
||
|
||
Once we know that the new Fcb has been initialized then we move our pointer
|
||
in the tree down to this position.
|
||
|
||
This routine does not own the Vcb lock on entry. We must be sure to release
|
||
it on exit.
|
||
|
||
Arguments:
|
||
|
||
IrpSp - Stack location for this request.
|
||
|
||
Vcb - Vcb for this volume.
|
||
|
||
CurrentFcb - On input this is the parent of the Fcb to open. On output we
|
||
store the Fcb for the file being opened.
|
||
|
||
DirName - This is always the exact name used to reach this file.
|
||
|
||
IgnoreCase - Indicates the type of case match for the open.
|
||
|
||
ShortNameMatch - Indicates if we are opening via the short name.
|
||
|
||
PathEntry - Path entry for the entry found.
|
||
|
||
PerformUserOpen - TRUE if we are to open this for a user, FALSE otherwise.
|
||
|
||
RelatedCcb - RelatedCcb for relative file object used to make this open.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Status indicating the result of the operation.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG CcbFlags = 0;
|
||
FILE_ID FileId;
|
||
|
||
BOOLEAN UnlockVcb = FALSE;
|
||
BOOLEAN FcbExisted;
|
||
|
||
PFCB NextFcb;
|
||
PFCB ParentFcb = NULL;
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Check for illegal access to this file.
|
||
//
|
||
|
||
if (PerformUserOpen &&
|
||
CdIllegalFcbAccess( IrpContext,
|
||
UserDirectoryOpen,
|
||
IrpSp->Parameters.Create.SecurityContext->DesiredAccess )) {
|
||
|
||
return STATUS_ACCESS_DENIED;
|
||
}
|
||
|
||
//
|
||
// Use a try-finally to facilitate cleanup.
|
||
//
|
||
|
||
_SEH2_TRY {
|
||
|
||
//
|
||
// Check the related Ccb to see if this was an OpenByFileId.
|
||
//
|
||
|
||
if (ARGUMENT_PRESENT( RelatedCcb ) &&
|
||
FlagOn( RelatedCcb->Flags, CCB_FLAG_OPEN_BY_ID | CCB_FLAG_OPEN_RELATIVE_BY_ID )) {
|
||
|
||
CcbFlags = CCB_FLAG_OPEN_RELATIVE_BY_ID;
|
||
}
|
||
|
||
if (IgnoreCase) {
|
||
|
||
SetFlag( CcbFlags, CCB_FLAG_IGNORE_CASE );
|
||
}
|
||
|
||
//
|
||
// Build the file Id for this file.
|
||
//
|
||
|
||
FileId.QuadPart = 0;
|
||
CdSetFidPathTableOffset( FileId, PathEntry->PathTableOffset );
|
||
CdFidSetDirectory( FileId );
|
||
|
||
//
|
||
// Lock the Vcb so we can examine the Fcb Table.
|
||
//
|
||
|
||
CdLockVcb( IrpContext, Vcb );
|
||
UnlockVcb = TRUE;
|
||
|
||
//
|
||
// Get the Fcb for this directory.
|
||
//
|
||
|
||
NextFcb = CdCreateFcb( IrpContext, FileId, CDFS_NTC_FCB_INDEX, &FcbExisted );
|
||
|
||
//
|
||
// If the Fcb was created here then initialize from the values in the
|
||
// path table entry.
|
||
//
|
||
|
||
if (!FcbExisted) {
|
||
|
||
CdInitializeFcbFromPathEntry( IrpContext, NextFcb, *CurrentFcb, PathEntry );
|
||
}
|
||
|
||
//
|
||
// Now try to acquire the new Fcb without waiting. We will reference
|
||
// the Fcb and retry with wait if unsuccessful.
|
||
//
|
||
|
||
if (!CdAcquireFcbExclusive( IrpContext, NextFcb, TRUE )) {
|
||
|
||
NextFcb->FcbReference += 1;
|
||
|
||
CdUnlockVcb( IrpContext, Vcb );
|
||
|
||
CdReleaseFcb( IrpContext, *CurrentFcb );
|
||
CdAcquireFcbExclusive( IrpContext, NextFcb, FALSE );
|
||
CdAcquireFcbExclusive( IrpContext, *CurrentFcb, FALSE );
|
||
|
||
CdLockVcb( IrpContext, Vcb );
|
||
NextFcb->FcbReference -= 1;
|
||
CdUnlockVcb( IrpContext, Vcb );
|
||
|
||
} else {
|
||
|
||
//
|
||
// Unlock the Vcb and move down to this new Fcb. Remember that we still
|
||
// own the parent however.
|
||
//
|
||
|
||
CdUnlockVcb( IrpContext, Vcb );
|
||
}
|
||
|
||
UnlockVcb = FALSE;
|
||
|
||
ParentFcb = *CurrentFcb;
|
||
*CurrentFcb = NextFcb;
|
||
|
||
// Lock object is acquired using internal state
|
||
_Analysis_suppress_lock_checking_(NextFcb->FcbNonpaged->FcbResource);
|
||
|
||
//
|
||
// Store this name into the prefix table for the parent.
|
||
//
|
||
|
||
if (ShortNameMatch) {
|
||
|
||
//
|
||
// Make sure the exact case is always in the tree.
|
||
//
|
||
|
||
CdInsertPrefix( IrpContext,
|
||
NextFcb,
|
||
DirName,
|
||
FALSE,
|
||
TRUE,
|
||
ParentFcb );
|
||
|
||
if (IgnoreCase) {
|
||
|
||
CdInsertPrefix( IrpContext,
|
||
NextFcb,
|
||
DirName,
|
||
TRUE,
|
||
TRUE,
|
||
ParentFcb );
|
||
}
|
||
|
||
} else {
|
||
|
||
//
|
||
// Make sure the exact case is always in the tree.
|
||
//
|
||
|
||
CdInsertPrefix( IrpContext,
|
||
NextFcb,
|
||
&PathEntry->CdDirName,
|
||
FALSE,
|
||
FALSE,
|
||
ParentFcb );
|
||
|
||
if (IgnoreCase) {
|
||
|
||
CdInsertPrefix( IrpContext,
|
||
NextFcb,
|
||
&PathEntry->CdCaseDirName,
|
||
TRUE,
|
||
FALSE,
|
||
ParentFcb );
|
||
}
|
||
}
|
||
|
||
//
|
||
// Release the parent Fcb at this point.
|
||
//
|
||
|
||
CdReleaseFcb( IrpContext, ParentFcb );
|
||
ParentFcb = NULL;
|
||
|
||
//
|
||
// Call our worker routine to complete the open.
|
||
//
|
||
|
||
if (PerformUserOpen) {
|
||
|
||
Status = CdCompleteFcbOpen( IrpContext,
|
||
IrpSp,
|
||
Vcb,
|
||
CurrentFcb,
|
||
UserDirectoryOpen,
|
||
CcbFlags,
|
||
IrpSp->Parameters.Create.SecurityContext->DesiredAccess );
|
||
}
|
||
|
||
} _SEH2_FINALLY {
|
||
|
||
//
|
||
// Unlock the Vcb if held.
|
||
//
|
||
|
||
if (UnlockVcb) {
|
||
|
||
CdUnlockVcb( IrpContext, Vcb );
|
||
}
|
||
|
||
//
|
||
// Release the parent if held.
|
||
//
|
||
|
||
if (ParentFcb != NULL) {
|
||
|
||
CdReleaseFcb( IrpContext, ParentFcb );
|
||
}
|
||
} _SEH2_END;
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
//
|
||
// Local support routine
|
||
//
|
||
|
||
_Requires_lock_held_(_Global_critical_region_)
|
||
NTSTATUS
|
||
CdOpenFileFromFileContext (
|
||
_In_ PIRP_CONTEXT IrpContext,
|
||
_In_ PIO_STACK_LOCATION IrpSp,
|
||
_In_ PVCB Vcb,
|
||
_Inout_ PFCB *CurrentFcb,
|
||
_In_ PCD_NAME FileName,
|
||
_In_ BOOLEAN IgnoreCase,
|
||
_In_ BOOLEAN ShortNameMatch,
|
||
_In_ PFILE_ENUM_CONTEXT FileContext,
|
||
_In_opt_ PCCB RelatedCcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to open a file where the file was found in a directory scan.
|
||
This should only be for a file in the case since we will find the directories in the
|
||
path table.
|
||
|
||
We first check that the desired access is legal for this file. Then we
|
||
construct the FileId for this and do a check to see if it is the Fcb
|
||
Table. It is always possible that either it was created since or simply
|
||
wasn't in the prefix table at the time of the prefix table search.
|
||
Initialize the Fcb and store into the FcbTable if not present.
|
||
|
||
Next we will add this to the prefix table of our parent if needed.
|
||
|
||
Once we know that the new Fcb has been initialized then we move our pointer
|
||
in the tree down to this position.
|
||
|
||
This routine does not own the Vcb lock on entry. We must be sure to release
|
||
it on exit.
|
||
|
||
Arguments:
|
||
|
||
IrpSp - Stack location for this request.
|
||
|
||
Vcb - Vcb for the current volume.
|
||
|
||
CurrentFcb - On input this is the parent of the Fcb to open. On output we
|
||
store the Fcb for the file being opened.
|
||
|
||
FileName - This is always the exact name used to reach this file.
|
||
|
||
IgnoreCase - Indicates the type of case of CaseName above.
|
||
|
||
ShortNameMatch - Indicates if we are opening via the short name.
|
||
|
||
FileContext - This is the context used to find the file.
|
||
|
||
RelatedCcb - RelatedCcb for relative file object used to make this open.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Status indicating the result of the operation.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG CcbFlags = 0;
|
||
FILE_ID FileId;
|
||
|
||
BOOLEAN UnlockVcb = FALSE;
|
||
BOOLEAN FcbExisted;
|
||
|
||
PFCB NextFcb;
|
||
PFCB ParentFcb = NULL;
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Check for illegal access to this file.
|
||
//
|
||
|
||
if (CdIllegalFcbAccess( IrpContext,
|
||
UserFileOpen,
|
||
IrpSp->Parameters.Create.SecurityContext->DesiredAccess )) {
|
||
|
||
return STATUS_ACCESS_DENIED;
|
||
}
|
||
|
||
//
|
||
// Use a try-finally to facilitate cleanup.
|
||
//
|
||
|
||
_SEH2_TRY {
|
||
|
||
//
|
||
// Check if a version number was used to open this file.
|
||
//
|
||
|
||
if (FileName->VersionString.Length != 0) {
|
||
|
||
SetFlag( CcbFlags, CCB_FLAG_OPEN_WITH_VERSION );
|
||
}
|
||
|
||
//
|
||
// Check the related Ccb to see if this was an OpenByFileId.
|
||
//
|
||
|
||
if (ARGUMENT_PRESENT( RelatedCcb ) &&
|
||
FlagOn( RelatedCcb->Flags, CCB_FLAG_OPEN_BY_ID | CCB_FLAG_OPEN_RELATIVE_BY_ID )) {
|
||
|
||
SetFlag( CcbFlags, CCB_FLAG_OPEN_RELATIVE_BY_ID );
|
||
}
|
||
|
||
if (IgnoreCase) {
|
||
|
||
SetFlag( CcbFlags, CCB_FLAG_IGNORE_CASE );
|
||
}
|
||
|
||
//
|
||
// Build the file Id for this file. We can use the path table offset from the
|
||
// parent and the directory offset from the dirent.
|
||
//
|
||
|
||
CdSetFidPathTableOffset( FileId, CdQueryFidPathTableOffset( (*CurrentFcb)->FileId ));
|
||
CdSetFidDirentOffset( FileId, FileContext->InitialDirent->Dirent.DirentOffset );
|
||
|
||
//
|
||
// Lock the Vcb so we can examine the Fcb Table.
|
||
//
|
||
|
||
CdLockVcb( IrpContext, Vcb );
|
||
UnlockVcb = TRUE;
|
||
|
||
//
|
||
// Get the Fcb for this file.
|
||
//
|
||
|
||
NextFcb = CdCreateFcb( IrpContext, FileId, CDFS_NTC_FCB_DATA, &FcbExisted );
|
||
|
||
//
|
||
// If the Fcb was created here then initialize from the values in the
|
||
// dirent.
|
||
//
|
||
|
||
if (!FcbExisted) {
|
||
|
||
CdInitializeFcbFromFileContext( IrpContext,
|
||
NextFcb,
|
||
*CurrentFcb,
|
||
FileContext );
|
||
}
|
||
|
||
//
|
||
// Now try to acquire the new Fcb without waiting. We will reference
|
||
// the Fcb and retry with wait if unsuccessful.
|
||
//
|
||
|
||
if (!CdAcquireFcbExclusive( IrpContext, NextFcb, TRUE )) {
|
||
|
||
NextFcb->FcbReference += 1;
|
||
|
||
CdUnlockVcb( IrpContext, Vcb );
|
||
|
||
CdReleaseFcb( IrpContext, *CurrentFcb );
|
||
CdAcquireFcbExclusive( IrpContext, NextFcb, FALSE );
|
||
CdAcquireFcbExclusive( IrpContext, *CurrentFcb, FALSE );
|
||
|
||
CdLockVcb( IrpContext, Vcb );
|
||
NextFcb->FcbReference -= 1;
|
||
CdUnlockVcb( IrpContext, Vcb );
|
||
|
||
} else {
|
||
|
||
//
|
||
// Unlock the Vcb and move down to this new Fcb. Remember that we still
|
||
// own the parent however.
|
||
//
|
||
|
||
CdUnlockVcb( IrpContext, Vcb );
|
||
}
|
||
|
||
UnlockVcb = FALSE;
|
||
|
||
ParentFcb = *CurrentFcb;
|
||
*CurrentFcb = NextFcb;
|
||
|
||
//
|
||
// Store this name into the prefix table for the parent.
|
||
//
|
||
|
||
|
||
if (ShortNameMatch) {
|
||
|
||
//
|
||
// Make sure the exact case is always in the tree.
|
||
//
|
||
|
||
CdInsertPrefix( IrpContext,
|
||
NextFcb,
|
||
FileName,
|
||
FALSE,
|
||
TRUE,
|
||
ParentFcb );
|
||
|
||
if (IgnoreCase) {
|
||
|
||
CdInsertPrefix( IrpContext,
|
||
NextFcb,
|
||
FileName,
|
||
TRUE,
|
||
TRUE,
|
||
ParentFcb );
|
||
}
|
||
|
||
//
|
||
// Insert this into the prefix table if we found this without
|
||
// using a version string.
|
||
//
|
||
|
||
} else if (FileName->VersionString.Length == 0) {
|
||
|
||
//
|
||
// Make sure the exact case is always in the tree.
|
||
//
|
||
|
||
CdInsertPrefix( IrpContext,
|
||
NextFcb,
|
||
&FileContext->InitialDirent->Dirent.CdFileName,
|
||
FALSE,
|
||
FALSE,
|
||
ParentFcb );
|
||
|
||
if (IgnoreCase) {
|
||
|
||
CdInsertPrefix( IrpContext,
|
||
NextFcb,
|
||
&FileContext->InitialDirent->Dirent.CdCaseFileName,
|
||
TRUE,
|
||
FALSE,
|
||
ParentFcb );
|
||
}
|
||
}
|
||
|
||
//
|
||
// Release the parent Fcb at this point.
|
||
//
|
||
|
||
_Analysis_assume_same_lock_(ParentFcb->FcbNonpaged->FcbResource, NextFcb->FcbNonpaged->FcbResource);
|
||
CdReleaseFcb( IrpContext, ParentFcb );
|
||
ParentFcb = NULL;
|
||
|
||
//
|
||
// Call our worker routine to complete the open.
|
||
//
|
||
|
||
Status = CdCompleteFcbOpen( IrpContext,
|
||
IrpSp,
|
||
Vcb,
|
||
CurrentFcb,
|
||
UserFileOpen,
|
||
CcbFlags,
|
||
IrpSp->Parameters.Create.SecurityContext->DesiredAccess );
|
||
|
||
} _SEH2_FINALLY {
|
||
|
||
//
|
||
// Unlock the Vcb if held.
|
||
//
|
||
|
||
if (UnlockVcb) {
|
||
|
||
CdUnlockVcb( IrpContext, Vcb );
|
||
}
|
||
|
||
//
|
||
// Release the parent if held.
|
||
//
|
||
|
||
if (ParentFcb != NULL) {
|
||
|
||
CdReleaseFcb( IrpContext, ParentFcb );
|
||
}
|
||
} _SEH2_END;
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
//
|
||
// Local support routine
|
||
//
|
||
|
||
_Requires_lock_held_(_Global_critical_region_)
|
||
NTSTATUS
|
||
CdCompleteFcbOpen (
|
||
_In_ PIRP_CONTEXT IrpContext,
|
||
_In_ PIO_STACK_LOCATION IrpSp,
|
||
_In_ PVCB Vcb,
|
||
_Inout_ PFCB *CurrentFcb,
|
||
_In_ TYPE_OF_OPEN TypeOfOpen,
|
||
_In_ ULONG UserCcbFlags,
|
||
_In_ ACCESS_MASK DesiredAccess
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This is the worker routine which takes an existing Fcb and completes
|
||
the open. We will do any necessary oplock checks and sharing checks.
|
||
Finally we will create the Ccb and update the file object and any
|
||
file object flags.
|
||
|
||
Arguments:
|
||
|
||
IrpSp - Stack location for the current request.
|
||
|
||
Vcb - Vcb for the current volume.
|
||
|
||
CurrentFcb - Address of pointer to Fcb to open. We clear this field if
|
||
we release the resource for this file.
|
||
|
||
TypeOfOpen - Type of open for this request.
|
||
|
||
UserCcbFlags - Flags to OR into the Ccb flags.
|
||
|
||
DesiredAccess - Desired access for this open.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - STATUS_SUCCESS if we complete this request, STATUS_PENDING if
|
||
the oplock package takes the Irp or SHARING_VIOLATION if there is a
|
||
sharing check conflict.
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS Status;
|
||
NTSTATUS OplockStatus = STATUS_SUCCESS;
|
||
ULONG Information = FILE_OPENED;
|
||
|
||
BOOLEAN LockVolume = FALSE;
|
||
|
||
PFCB Fcb = *CurrentFcb;
|
||
PCCB Ccb;
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Expand maximum allowed to something sensible for share access checking
|
||
//
|
||
|
||
if (MAXIMUM_ALLOWED == DesiredAccess) {
|
||
|
||
DesiredAccess = FILE_ALL_ACCESS & ~((TypeOfOpen != UserVolumeOpen ?
|
||
(FILE_WRITE_ATTRIBUTES |
|
||
FILE_WRITE_DATA |
|
||
FILE_WRITE_EA |
|
||
FILE_ADD_FILE |
|
||
FILE_ADD_SUBDIRECTORY |
|
||
FILE_APPEND_DATA) : 0) |
|
||
FILE_DELETE_CHILD |
|
||
DELETE |
|
||
WRITE_DAC );
|
||
}
|
||
|
||
//
|
||
// If this a volume open and the user wants to lock the volume then
|
||
// purge and lock the volume.
|
||
//
|
||
|
||
if ((TypeOfOpen <= UserVolumeOpen) &&
|
||
!FlagOn( IrpSp->Parameters.Create.ShareAccess, FILE_SHARE_READ )) {
|
||
|
||
//
|
||
// If there are open handles then fail this immediately.
|
||
//
|
||
|
||
if (Vcb->VcbCleanup != 0) {
|
||
|
||
return STATUS_SHARING_VIOLATION;
|
||
}
|
||
|
||
//
|
||
// If we can't wait then force this to be posted.
|
||
//
|
||
|
||
if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
|
||
|
||
CdRaiseStatus( IrpContext, STATUS_CANT_WAIT );
|
||
}
|
||
|
||
LockVolume = TRUE;
|
||
|
||
//
|
||
// Purge the volume and make sure all of the user references
|
||
// are gone.
|
||
//
|
||
|
||
Status = CdPurgeVolume( IrpContext, Vcb, FALSE );
|
||
|
||
if (Status != STATUS_SUCCESS) {
|
||
|
||
return Status;
|
||
}
|
||
|
||
//
|
||
// Now force all of the delayed close operations to go away.
|
||
//
|
||
|
||
CdFspClose( Vcb );
|
||
|
||
if (Vcb->VcbUserReference > CDFS_RESIDUAL_USER_REFERENCE) {
|
||
|
||
return STATUS_SHARING_VIOLATION;
|
||
}
|
||
}
|
||
|
||
//
|
||
// If the Fcb already existed then we need to check the oplocks and
|
||
// the share access.
|
||
//
|
||
|
||
if (Fcb->FcbCleanup != 0) {
|
||
|
||
//
|
||
// If this is a user file open then check whether there are any
|
||
// batch oplock.
|
||
//
|
||
|
||
if (TypeOfOpen == UserFileOpen) {
|
||
|
||
//
|
||
// Store the address of the Fcb for a possible teardown into
|
||
// the IrpContext. We will release this in the call to
|
||
// prepost the Irp.
|
||
//
|
||
|
||
IrpContext->TeardownFcb = CurrentFcb;
|
||
|
||
if (FsRtlCurrentBatchOplock( CdGetFcbOplock(Fcb) )) {
|
||
|
||
//
|
||
// We remember if a batch oplock break is underway for the
|
||
// case where the sharing check fails.
|
||
//
|
||
|
||
Information = FILE_OPBATCH_BREAK_UNDERWAY;
|
||
|
||
OplockStatus = FsRtlCheckOplock( CdGetFcbOplock(Fcb),
|
||
IrpContext->Irp,
|
||
IrpContext,
|
||
(PVOID)CdOplockComplete, /* ReactOS Change: GCC "assignment from incompatible pointer type" */
|
||
(PVOID)CdPrePostIrp ); /* ReactOS Change: GCC "assignment from incompatible pointer type" */
|
||
|
||
if (OplockStatus == STATUS_PENDING) {
|
||
|
||
return STATUS_PENDING;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Check the share access before breaking any exclusive oplocks.
|
||
//
|
||
|
||
Status = IoCheckShareAccess( DesiredAccess,
|
||
IrpSp->Parameters.Create.ShareAccess,
|
||
IrpSp->FileObject,
|
||
&Fcb->ShareAccess,
|
||
FALSE );
|
||
|
||
if (!NT_SUCCESS( Status )) {
|
||
|
||
return Status;
|
||
}
|
||
|
||
//
|
||
// Now check that we can continue based on the oplock state of the
|
||
// file.
|
||
//
|
||
|
||
OplockStatus = FsRtlCheckOplock( CdGetFcbOplock(Fcb),
|
||
IrpContext->Irp,
|
||
IrpContext,
|
||
(PVOID)CdOplockComplete,/* ReactOS Change: GCC "assignment from incompatible pointer type" */
|
||
(PVOID)CdPrePostIrp );/* ReactOS Change: GCC "assignment from incompatible pointer type" */
|
||
|
||
if (OplockStatus == STATUS_PENDING) {
|
||
|
||
return STATUS_PENDING;
|
||
}
|
||
|
||
IrpContext->TeardownFcb = NULL;
|
||
|
||
//
|
||
// Otherwise just do the sharing check.
|
||
//
|
||
|
||
} else {
|
||
|
||
Status = IoCheckShareAccess( DesiredAccess,
|
||
IrpSp->Parameters.Create.ShareAccess,
|
||
IrpSp->FileObject,
|
||
&Fcb->ShareAccess,
|
||
FALSE );
|
||
|
||
if (!NT_SUCCESS( Status )) {
|
||
|
||
return Status;
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// Create the Ccb now.
|
||
//
|
||
|
||
Ccb = CdCreateCcb( IrpContext, Fcb, UserCcbFlags );
|
||
|
||
//
|
||
// Update the share access.
|
||
//
|
||
|
||
if (Fcb->FcbCleanup == 0) {
|
||
|
||
IoSetShareAccess( DesiredAccess,
|
||
IrpSp->Parameters.Create.ShareAccess,
|
||
IrpSp->FileObject,
|
||
&Fcb->ShareAccess );
|
||
|
||
} else {
|
||
|
||
IoUpdateShareAccess( IrpSp->FileObject, &Fcb->ShareAccess );
|
||
}
|
||
|
||
//
|
||
// Set the file object type.
|
||
//
|
||
|
||
CdSetFileObject( IrpContext, IrpSp->FileObject, TypeOfOpen, Fcb, Ccb );
|
||
|
||
//
|
||
// Set the appropriate cache flags for a user file object.
|
||
//
|
||
|
||
if (TypeOfOpen == UserFileOpen) {
|
||
|
||
if (FlagOn( IrpSp->Parameters.Create.Options, FILE_NO_INTERMEDIATE_BUFFERING )) {
|
||
|
||
SetFlag( IrpSp->FileObject->Flags, FO_NO_INTERMEDIATE_BUFFERING );
|
||
|
||
} else {
|
||
|
||
SetFlag( IrpSp->FileObject->Flags, FO_CACHE_SUPPORTED );
|
||
}
|
||
}
|
||
else if (TypeOfOpen == UserVolumeOpen) {
|
||
|
||
SetFlag( IrpSp->FileObject->Flags, FO_NO_INTERMEDIATE_BUFFERING );
|
||
}
|
||
|
||
//
|
||
// Update the open and cleanup counts. Check the fast io state here.
|
||
//
|
||
|
||
CdLockVcb( IrpContext, Vcb );
|
||
|
||
CdIncrementCleanupCounts( IrpContext, Fcb );
|
||
CdIncrementReferenceCounts( IrpContext, Fcb, 1, 1 );
|
||
|
||
if (LockVolume) {
|
||
|
||
Vcb->VolumeLockFileObject = IrpSp->FileObject;
|
||
SetFlag( Vcb->VcbState, VCB_STATE_LOCKED );
|
||
}
|
||
|
||
CdUnlockVcb( IrpContext, Vcb );
|
||
|
||
CdLockFcb( IrpContext, Fcb );
|
||
|
||
if (TypeOfOpen == UserFileOpen) {
|
||
|
||
Fcb->IsFastIoPossible = CdIsFastIoPossible( Fcb );
|
||
|
||
} else {
|
||
|
||
Fcb->IsFastIoPossible = FastIoIsNotPossible;
|
||
}
|
||
|
||
CdUnlockFcb( IrpContext, Fcb );
|
||
|
||
//
|
||
// Show that we opened the file.
|
||
//
|
||
|
||
IrpContext->Irp->IoStatus.Information = Information;
|
||
|
||
//
|
||
// Point to the section object pointer in the non-paged Fcb.
|
||
//
|
||
|
||
IrpSp->FileObject->SectionObjectPointer = &Fcb->FcbNonpaged->SegmentObject;
|
||
return OplockStatus;
|
||
}
|
||
|
||
|
||
|
||
|
||
|