|
|
//+----------------------------------------------------------------------------
//
// File: create.c
//
// Contents:
//
// This module implements the File Create routine for Dfs called by the
// dispatch driver. Unlike traditional disk-based FSDs, there is only
// one entry point, DfsFsdCreate. The request is assumed to be
// synchronous (whether the user thread requests it or not).
// Of course, since we will typically be calling out to some other
// FSD, that FSD may post the request and return to us with a
// STATUS_PENDING.
//
// Functions: DfsFsdCreate - FSD entry point for NtCreateFile/NtOpenFile
// DfsCommonCreate, local
// DfsPassThroughRelativeOpen, local
// DfsCompleteRelativeOpen, local
// DfsPostProcessRelativeOpen, local
// DfsRestartRelativeOpen, local
// DfsComposeFullName, local
// DfsAreFilesOnSameLocalVolume, local
//
// History: 27 Jan 1992 AlanW Created.
//
//-----------------------------------------------------------------------------
#include "dfsprocs.h"
#include "dnr.h"
#include "fcbsup.h"
#include "mupwml.h"
//
// The debug trace level
//
#define Dbg (DEBUG_TRACE_CREATE)
//
// Local procedure prototypes
//
NTSTATUSDfsCommonCreate ( OPTIONAL IN PIRP_CONTEXT IrpContext, PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
IO_STATUS_BLOCKDfsOpenDevice ( IN PIRP_CONTEXT IrpContext, IN PFILE_OBJECT FileObject, IN PDEVICE_OBJECT DeviceObject, IN ACCESS_MASK DesiredAccess, IN USHORT ShareAccess, IN ULONG CreateOptions);
NTSTATUSDfsPassThroughRelativeOpen( IN PIRP Irp, IN PIRP_CONTEXT IrpContext, IN PDFS_FCB ParentFcb);
NTSTATUSDfsCompleteRelativeOpen( IN PDEVICE_OBJECT pDevice, IN PIRP Irp, IN PVOID Context);
NTSTATUSDfsPostProcessRelativeOpen( IN PIRP Irp, IN PIRP_CONTEXT IrpContext, IN PDFS_FCB ParentFcb);
VOIDDfsRestartRelativeOpen( IN PIRP_CONTEXT IrpContext);
NTSTATUSDfsComposeFullName( IN PUNICODE_STRING ParentName, IN PUNICODE_STRING RelativeName, OUT PUNICODE_STRING FullName);
NTSTATUSDfsAreFilesOnSameLocalVolume( IN PUNICODE_STRING ParentName, IN PUNICODE_STRING FileName);
#ifdef ALLOC_PRAGMA
#pragma alloc_text( PAGE, DfsFsdCreate )
#pragma alloc_text( PAGE, DfsCommonCreate )
#pragma alloc_text( PAGE, DfsOpenDevice )
#pragma alloc_text( PAGE, DfsPassThroughRelativeOpen )
#pragma alloc_text( PAGE, DfsPostProcessRelativeOpen )
#pragma alloc_text( PAGE, DfsRestartRelativeOpen )
#pragma alloc_text( PAGE, DfsComposeFullName )
#pragma alloc_text( PAGE, DfsAreFilesOnSameLocalVolume )
//
// The following are not pageable since they can be called at DPC level
//
// DfsCompleteRelativeOpen
//
#endif // ALLOC_PRAGMA
//+-------------------------------------------------------------------
//
// Function: DfsFsdCreate, public
//
// Synopsis: This routine implements the FSD part of the NtCreateFile
// and NtOpenFile API calls.
//
// Arguments: [DeviceObject] -- Supplies the device object where
// the file/directory exists that we are trying
// to open/create exists
// [Irp] - Supplies the Irp being processed
//
// Returns: NTSTATUS - The Fsd status for the Irp
//
//--------------------------------------------------------------------
NTSTATUSDfsFsdCreate ( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ){ NTSTATUS Status; PIRP_CONTEXT IrpContext = NULL; PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp); PFILE_OBJECT FileObject = IrpSp->FileObject; PDFS_FCB pFcb = NULL;
DfsDbgTrace(+1, Dbg, "DfsFsdCreate: Entered\n", 0);
MUP_TRACE_HIGH(TRACE_IRP, DfsFsdCreate_Entry, LOGPTR(DeviceObject) LOGPTR(FileObject) LOGUSTR(FileObject->FileName) LOGPTR(Irp));
ASSERT(IoIsOperationSynchronous(Irp) == TRUE);
//
// Call the common create routine, with block allowed if the operation
// is synchronous.
//
try {
IrpContext = DfsCreateIrpContext( Irp, CanFsdWait( Irp ) ); if (IrpContext == NULL) ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES); Status = DfsCommonCreate( IrpContext, DeviceObject, Irp );
} except( DfsExceptionFilter( IrpContext, GetExceptionCode(), GetExceptionInformation() )) {
//
// We had some trouble trying to perform the requested
// operation, so we'll abort the I/O request with
// the error status that we get back from the
// execption code
//
Status = DfsProcessException( IrpContext, Irp, GetExceptionCode() );
}
//
// And return to our caller
//
DfsDbgTrace(-1, Dbg, "DfsFsdCreate: Exit -> %08lx\n", ULongToPtr(Status) ); MUP_TRACE_HIGH(TRACE_IRP, DfsFsdCreate_Exit, LOGSTATUS(Status) LOGPTR(DeviceObject) LOGPTR(FileObject) LOGPTR(Irp)); return Status;}
//+-------------------------------------------------------------------
// Function: DfsCommonCreate, private
//
// Synopsis: This is the common routine for creating/opening a file
// called by both the FSD and FSP threads.
//
// Arguments: [DeviceObject] - The device object associated with
// the request.
// [Irp] -- Supplies the Irp to process
//
// Returns: NTSTATUS - the return status for the operation
//
//--------------------------------------------------------------------
NTSTATUSDfsCommonCreate ( OPTIONAL IN PIRP_CONTEXT IrpContext, IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ){
IO_STATUS_BLOCK Iosb; PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp ); PDFS_VCB Vcb = NULL; PDFS_FCB Fcb = NULL;
PFILE_OBJECT FileObject = IrpSp->FileObject; PFILE_OBJECT RelatedFileObject; UNICODE_STRING FileName; ACCESS_MASK DesiredAccess; ULONG CreateOptions; USHORT ShareAccess; NTSTATUS Status; LARGE_INTEGER StartTime; LARGE_INTEGER EndTime;
DfsDbgTrace(+1, Dbg, "DfsCommonCreate\n", 0 ); DfsDbgTrace( 0, Dbg, "Irp = %08lx\n", Irp ); DfsDbgTrace( 0, Dbg, "->Flags = %08lx\n", ULongToPtr(Irp->Flags) ); DfsDbgTrace( 0, Dbg, "->FileObject = %08lx\n", FileObject ); DfsDbgTrace( 0, Dbg, " ->RelatedFileObject = %08lx\n", FileObject->RelatedFileObject ); DfsDbgTrace( 0, Dbg, " ->FileName = %wZ\n", &FileObject->FileName ); DfsDbgTrace( 0, Dbg, "->DesiredAccess = %08lx\n", ULongToPtr(IrpSp->Parameters.Create.SecurityContext->DesiredAccess) ); DfsDbgTrace( 0, Dbg, "->CreateOptions = %08lx\n", ULongToPtr(IrpSp->Parameters.Create.Options) ); DfsDbgTrace( 0, Dbg, "->FileAttributes = %04x\n", IrpSp->Parameters.Create.FileAttributes ); DfsDbgTrace( 0, Dbg, "->ShareAccess = %04x\n", IrpSp->Parameters.Create.ShareAccess ); DfsDbgTrace( 0, Dbg, "->EaLength = %08lx\n", ULongToPtr(IrpSp->Parameters.Create.EaLength) );
KeQuerySystemTime(&StartTime);#if DBG
if (MupVerbose) { KeQuerySystemTime(&EndTime); DbgPrint("[%d] DfsCommonCreate(%wZ)\n", (ULONG)((EndTime.QuadPart - StartTime.QuadPart)/(10 * 1000)), &FileObject->FileName); }#endif
//
// Reference our input parameters to make things easier
//
RelatedFileObject = IrpSp->FileObject->RelatedFileObject; FileName = *((PUNICODE_STRING) &IrpSp->FileObject->FileName); DesiredAccess = IrpSp->Parameters.Create.SecurityContext->DesiredAccess; CreateOptions = IrpSp->Parameters.Create.Options; ShareAccess = IrpSp->Parameters.Create.ShareAccess;
Iosb.Status = STATUS_SUCCESS;
//
// Short circuit known invalid opens.
//
if ((IrpSp->Flags & SL_OPEN_PAGING_FILE) != 0) {
DfsDbgTrace(0, Dbg, "DfsCommonCreate: Paging file not allowed on Dfs\n", 0);
Iosb.Status = STATUS_INVALID_PARAMETER;
MUP_TRACE_HIGH(ERROR, DfsCommonCreate_Error_PagingFileNotAllowed, LOGSTATUS(Iosb.Status) LOGPTR(DeviceObject) LOGPTR(FileObject) LOGPTR(Irp));
DfsCompleteRequest( IrpContext, Irp, Iosb.Status );
DfsDbgTrace(-1, Dbg, "DfsCommonCreate: Exit -> %08lx\n", ULongToPtr(Iosb.Status));
return Iosb.Status;
}
//
// There are several cases we need to handle here.
//
// 1. FileName is 0 length
//
// If the filename length is 0, then someone really wants to open the
// device object itself.
//
// 2. This is a Relative open and the parent is on the same volume,
// either local or remote.
//
// We pass through the relative open to the driver that opened the
// parent.
//
// 3. This is a relative open and the parent is on a different volume.
//
// Form the full name of the file by concatenating the parent's
// name with the relative file name. Stick this name in the FileObject
// and do DNR on the full name.
//
// 4. This is a relative open and the parent is a device object (ie,
// the parent was opened via case 1)
//
// Assume the parent name is \, so concatenate \ with the relative
// file name. Stick this name in the FileObject and do DNR on the
// the full name.
//
// 5. This is an absolute open, (or a case 3/4 converted to an absolute
// open), and the SL_OPEN_TARGET_DIRECTORY bis *is* set.
//
// a. If the file's immediate parent directory is on the same local
// volume as the file, then do a regular DNR, and let the
// underlying FS handle the SL_OPEN_TARGET_DIRECTORY.
//
// b. If the file's immediate parent directory is on a local volume
// and the file is not on the same local volume, then immediately
// return STATUS_NOT_SAME_DEVICE.
//
// c. If the file's immediate parent directory is on a remote volume,
// then do a full DNR. This will pass through the
// SL_OPEN_TARGET_DIRECTORY to the remote Dfs driver, which will
// handle it as case 5a. or 5b.
//
// 6. This is an absolute open, (or a case 3/4 converted to an absolute
// open), and the SL_OPEN_TARGET_DIRECTORY bit is *not* set.
//
// Do a DNR on the FileObject's name.
//
try {
//
// Check to see if we are opening a device object. If so, and the
// file is being opened on the File system device object, it will
// only permit FsCtl and Close operations to be performed.
//
if ( (FileName.Length == 0 && RelatedFileObject == NULL) || (DeviceObject != NULL && DeviceObject->DeviceType != FILE_DEVICE_DFS && RelatedFileObject == NULL) ) {
//
// This is case 1.
//
// In this case there had better be a DeviceObject
//
ASSERT(ARGUMENT_PRESENT(DeviceObject));
DfsDbgTrace(0, Dbg, "DfsCommonCreate: Opening the device, DevObj = %08lx\n", DeviceObject);
Iosb = DfsOpenDevice( IrpContext, FileObject, DeviceObject, DesiredAccess, ShareAccess, CreateOptions);
Irp->IoStatus.Information = Iosb.Information;
DfsCompleteRequest( IrpContext, Irp, Iosb.Status );
try_return( Iosb.Status );
}
if (DeviceObject != NULL && DeviceObject->DeviceType == FILE_DEVICE_DFS) { Vcb = &(((PLOGICAL_ROOT_DEVICE_OBJECT)DeviceObject)->Vcb); }
//
// If there is a related file object, then this is a relative open.
//
if (RelatedFileObject != NULL) {
//
// This is case 2, 3, or 4.
//
PDFS_VCB TempVcb; TYPE_OF_OPEN OpenType; UNICODE_STRING NewFileName;
OpenType = DfsDecodeFileObject( RelatedFileObject, &TempVcb, &Fcb);
if (OpenType == RedirectedFileOpen) {
DfsDbgTrace(0, Dbg, "Relative file open: DFS_FCB = %08x\n", Fcb); DfsDbgTrace(0, Dbg, " Directory: %wZ\n", &Fcb->FullFileName); DfsDbgTrace(0, Dbg, " Relative file: %wZ\n", &FileName);
//
// This is case 2.
//
DfsDbgTrace(0, Dbg, "Trying pass through of relative open\n", 0);
Iosb.Status = DfsPassThroughRelativeOpen( Irp, IrpContext, Fcb );
try_return( Iosb.Status );
} else if (OpenType == LogicalRootDeviceOpen) {
//
// This is case 4.
//
// If the open is relative to a logical root open, then we
// are forced to convert it to an absolute open, since there
// is no underlying FS backing up the logical root to pass
// the relative open to first.
//
DfsDbgTrace( 0, Dbg, "DfsCommonCreate: Open relative to Logical Root\n", 0);
ASSERT (TempVcb == Vcb);
NewFileName.MaximumLength = sizeof (WCHAR) + FileName.Length;
NewFileName.Buffer = (PWCHAR) ExAllocatePoolWithTag( NonPagedPool, NewFileName.MaximumLength, ' puM');
if (NewFileName.Buffer == NULL) {
Iosb.Status = STATUS_INSUFFICIENT_RESOURCES;
DfsCompleteRequest( IrpContext, Irp, Iosb.Status );
try_return( Iosb.Status );
}
NewFileName.Buffer[0] = L'\\';
NewFileName.Length = sizeof (WCHAR);
} else {
Iosb.Status = STATUS_INVALID_HANDLE;
DfsCompleteRequest( IrpContext, Irp, Iosb.Status );
DfsDbgTrace(0, Dbg, "DfsCommonCreate: Invalid related file object\n", 0);
try_return( Iosb.Status );
}
(void) DnrConcatenateFilePath ( &NewFileName, FileName.Buffer, FileName.Length);
if (IrpSp->FileObject->FileName.Buffer) ExFreePool( IrpSp->FileObject->FileName.Buffer );
FileName = IrpSp->FileObject->FileName = NewFileName;
}
ASSERT(FileName.Length != 0);
//
// This is case 5b, 5c, or 6 - Do a full DNR.
//
if (Vcb == NULL) {
DfsDbgTrace(0, Dbg, "DfsCommonCreate: Null Vcb!\n", 0);
Iosb.Status = STATUS_INVALID_PARAMETER; MUP_TRACE_HIGH(ERROR, DfsCommonCreate_Error_NullVcb, LOGSTATUS(Iosb.Status) LOGPTR(DeviceObject) LOGPTR(FileObject) LOGPTR(Irp)); DfsCompleteRequest(IrpContext, Irp, Iosb.Status);
try_return(Iosb.Status);
}
Iosb.Status = DnrStartNameResolution(IrpContext, Irp, Vcb);
try_exit: NOTHING; } finally {
DfsDbgTrace(-1, Dbg, "DfsCommonCreate: Exit -> %08lx\n", ULongToPtr(Iosb.Status));#if DBG
if (MupVerbose) { KeQuerySystemTime(&EndTime); DbgPrint("[%d] DfsCommonCreate exit 0x%x\n", (ULONG)((EndTime.QuadPart - StartTime.QuadPart)/(10 * 1000)), Iosb.Status); }#endif
}
return Iosb.Status;}
//+-------------------------------------------------------------------
//
// Function: DfsOpenDevice, local
//
// Synopsis: This routine opens the specified device for direct
// access.
//
// Arguments: [FileObject] - Supplies the File object
// [DeviceObject] - Supplies the object denoting the device
// being opened
// [DesiredAccess] - Supplies the desired access of the caller
// [ShareAccess] - Supplies the share access of the caller
// [CreateOptions] - Supplies the create options for
// this operation
//
// Returns: [IO_STATUS_BLOCK] - Returns the completion status for
// the operation
//
//--------------------------------------------------------------------
IO_STATUS_BLOCKDfsOpenDevice ( IN PIRP_CONTEXT IrpContext, IN PFILE_OBJECT FileObject, IN PDEVICE_OBJECT DeviceObject, IN ACCESS_MASK DesiredAccess, IN USHORT ShareAccess, IN ULONG CreateOptions) { IO_STATUS_BLOCK Iosb; PDFS_VCB Vcb = NULL;
//
// The following variables are for abnormal termination
//
BOOLEAN UnwindShareAccess = FALSE; BOOLEAN UnwindVolumeLock = FALSE;
DfsDbgTrace( +1, Dbg, "DfsOpenDevice: Entered\n", 0 );
try {
//
// Check to see which type of device is being opened.
// We don't permit all open modes on the file system
// device object.
//
if (DeviceObject->DeviceType == FILE_DEVICE_DFS_FILE_SYSTEM ) { ULONG CreateDisposition = (CreateOptions >> 24) & 0x000000ff;
//
// Check for proper desired access and rights
//
if (CreateDisposition != FILE_OPEN && CreateDisposition != FILE_OPEN_IF ) {
Iosb.Status = STATUS_ACCESS_DENIED; MUP_TRACE_HIGH(ERROR, DfsOpenDevice_Error_BadDisposition, LOGSTATUS(Iosb.Status) LOGPTR(DeviceObject) LOGPTR(FileObject)); try_return( Iosb ); }
//
// Check if we were to open a directory
//
if (CreateOptions & FILE_DIRECTORY_FILE) { DfsDbgTrace(0, Dbg, "DfsOpenDevice: Cannot open device as a directory\n", 0);
Iosb.Status = STATUS_NOT_A_DIRECTORY; MUP_TRACE_HIGH(ERROR, DfsOpenDevice_Error_CannotOpenAsDirectory, LOGSTATUS(Iosb.Status) LOGPTR(DeviceObject) LOGPTR(FileObject)); try_return( Iosb ); }
DfsSetFileObject( FileObject, FilesystemDeviceOpen, DeviceObject );
Iosb.Status = STATUS_SUCCESS; Iosb.Information = FILE_OPENED; try_return( Iosb ); }
ExAcquireResourceExclusiveLite(&DfsData.Resource, TRUE); Vcb = & (((PLOGICAL_ROOT_DEVICE_OBJECT)DeviceObject)->Vcb);
//
// If the user does not want to share anything then we will try and
// take out a lock on the volume. We check if the volume is already
// in use, and if it is then we deny the open
//
if ((ShareAccess & ( FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)) == 0 ) {
if (Vcb->OpenFileCount != 0) {
ExReleaseResourceLite( &DfsData.Resource ); Iosb.Status = STATUS_ACCESS_DENIED; MUP_TRACE_HIGH(ERROR, DfsOpenDevice_Error_FileInUse, LOGSTATUS(Iosb.Status) LOGPTR(DeviceObject) LOGPTR(FileObject));
try_return( Iosb ); }
//
// Lock the volume
//
Vcb->VcbState |= VCB_STATE_FLAG_LOCKED; Vcb->FileObjectWithVcbLocked = FileObject; UnwindVolumeLock = TRUE; }
//
// If the volume is already opened by someone then we need to check
// the share access
//
if (Vcb->DirectAccessOpenCount > 0) {
if ( !NT_SUCCESS( Iosb.Status = IoCheckShareAccess( DesiredAccess, ShareAccess, FileObject, &Vcb->ShareAccess, TRUE ))) { ExReleaseResourceLite( &DfsData.Resource );
MUP_TRACE_ERROR_HIGH(Iosb.Status, ALL_ERROR, DfsOpenDevice_Error_IoCheckShareAccess, LOGSTATUS(Iosb.Status) LOGPTR(DeviceObject) LOGPTR(FileObject));
try_return( Iosb ); }
} else {
IoSetShareAccess( DesiredAccess, ShareAccess, FileObject, &Vcb->ShareAccess ); }
UnwindShareAccess = TRUE;
//
// Bug: 425017. Update the counters with lock held to avoid race between multiple processors.
//
InterlockedIncrement(&Vcb->DirectAccessOpenCount); InterlockedIncrement(&Vcb->OpenFileCount);
ExReleaseResourceLite( &DfsData.Resource ); //
// Setup the context pointers, and update
// our reference counts
//
DfsSetFileObject( FileObject, LogicalRootDeviceOpen, Vcb );
//
// And set our status to success
//
Iosb.Status = STATUS_SUCCESS; Iosb.Information = FILE_OPENED;
try_exit: NOTHING; } finally {
//
// If this is an abnormal termination then undo our work
//
if (AbnormalTermination() && (Vcb != NULL)) {
if (UnwindShareAccess) { IoRemoveShareAccess( FileObject, &Vcb->ShareAccess ); }
if (UnwindVolumeLock) { Vcb->VcbState &= ~VCB_STATE_FLAG_LOCKED; Vcb->FileObjectWithVcbLocked = NULL; }
}
DfsDbgTrace(-1, Dbg, "DfsOpenDevice: Exit -> Iosb.Status = %08lx\n", ULongToPtr(Iosb.Status)); }
return Iosb;}
//+----------------------------------------------------------------------------
//
// Function: DfsPassThroughRelativeOpen
//
// Synopsis: Passes through a relative open call to the device handling
// the parent. This is required for structured storages on OFS
// to work, for replication's Do-not-cross-JP sematics to work,
// and as an optimization.
//
// Arguments: [Irp] -- The open Irp, which we will pass through.
// [IrpContext] -- Associated with the above Irp.
// [ParentFcb] -- Fcb of related file object.
//
// Returns: Status returned by the underlying FS, or by DNR if
// the underlying FS complained about STATUS_DFS_EXIT_PATH_FOUND.
//
//-----------------------------------------------------------------------------
NTSTATUSDfsPassThroughRelativeOpen( IN PIRP Irp, IN PIRP_CONTEXT IrpContext, IN PDFS_FCB ParentFcb){
NTSTATUS Status; PIO_STACK_LOCATION IrpSp, NextIrpSp; PFILE_OBJECT FileObject; PDFS_FCB NewFcb; UNICODE_STRING NewFileName;
DfsDbgTrace(+1, Dbg, "DfsPassThroughRelativeOpen: Entered\n", 0);
IrpSp = IoGetCurrentIrpStackLocation(Irp); FileObject = IrpSp->FileObject;
//
// Prepare to pass the request to the device handling the parent open.
//
//
// First, we preallocate an DFS_FCB, assuming that the relative open will
// succeed. We need to do this at this point in time because the
// FileObject->FileName is still intact; after we pass through, the
// underlying can do as it wishes with the FileName field, and we will
// be unable to construct the full file name for the DFS_FCB.
//
Status = DfsComposeFullName( &ParentFcb->FullFileName, &IrpSp->FileObject->FileName, &NewFileName);
if (!NT_SUCCESS(Status)) { DfsDbgTrace(-1, Dbg, "DfsPassThroughRelativeOpen: Unable to create full Name %08lx\n", ULongToPtr(Status) ); DfsCompleteRequest( IrpContext, Irp, Status ); return( Status ); }
NewFcb = DfsCreateFcb( NULL, ParentFcb->Vcb, &NewFileName );
if (NewFcb == NULL) {
if (NewFileName.Buffer != NULL) ExFreePool(NewFileName.Buffer); Status = STATUS_INSUFFICIENT_RESOURCES; DfsDbgTrace(-1, Dbg, "DfsPassThroughRelativeOpen: Exited %08lx\n", ULongToPtr(Status));
DfsCompleteRequest( IrpContext, Irp, Status ); return( Status );
}
// Changes for 426540. Do all the right logic for CSC.
// since DFS does not "failover" for relative names, allow CSC to go
// offline if necessary to serve the name. This does mean that the DFS
// namespace will be served by the CSC even when one of the DFS alternates
// exists.
NewFcb->DfsNameContext.Flags = DFS_FLAG_LAST_ALTERNATE;
if (NewFcb->Vcb != NULL) { if (NewFcb->Vcb->VcbState & VCB_STATE_CSCAGENT_VOLUME) { NewFcb->DfsNameContext.NameContextType = DFS_CSCAGENT_NAME_CONTEXT; } else { NewFcb->DfsNameContext.NameContextType = DFS_USER_NAME_CONTEXT; } }
NewFcb->TargetDevice = ParentFcb->TargetDevice; NewFcb->ProviderId = ParentFcb->ProviderId; NewFcb->DfsMachineEntry = ParentFcb->DfsMachineEntry; NewFcb->FileObject = IrpSp->FileObject;
DfsSetFileObject(IrpSp->FileObject, RedirectedFileOpen, NewFcb );
IrpSp->FileObject->FsContext = &(NewFcb->DfsNameContext); if (ParentFcb->ProviderId == PROV_ID_DFS_RDR) { IrpSp->FileObject->FsContext2 = UIntToPtr(DFS_OPEN_CONTEXT); }
if (NewFileName.Buffer != NULL) ExFreePool( NewFileName.Buffer );
//
// Next, setup the IRP stack location
//
NextIrpSp = IoGetNextIrpStackLocation(Irp); (*NextIrpSp) = (*IrpSp);
//
// Put the parent DFS_FCB pointer in the IrpContext.
//
IrpContext->Context = (PVOID) NewFcb;
IoSetCompletionRoutine( Irp, DfsCompleteRelativeOpen, IrpContext, TRUE, TRUE, TRUE);
Status = IoCallDriver( ParentFcb->TargetDevice, Irp ); MUP_TRACE_ERROR_HIGH(Status, ALL_ERROR, DfsPassThroughRelativeOpen_Error_IoCallDriver, LOGSTATUS(Status) LOGPTR(FileObject) LOGPTR(Irp));
DfsDbgTrace(0, Dbg, "IoCallDriver returned %08lx\n", ULongToPtr(Status));
if (Status != STATUS_PENDING) {
Status = DfsPostProcessRelativeOpen( Irp, IrpContext, NewFcb);
}
DfsDbgTrace(-1, Dbg, "DfsPassThroughRelativeOpen: Exited %08lx\n", ULongToPtr(Status));
return( Status );
}
//+----------------------------------------------------------------------------
//
// Function: DfsCompleteRelativeOpen
//
// Synopsis: Completion routine for DfsPassThroughRelativeOpen. It is
// interesting only in case where STATUS_PENDING was originally
// returned from IoCallDriver. If so, then this routine simply
// queues DfsRestartRelativeOpen to a work queue. Note that it
// must queue an item at this stage instead of doing the work
// itself because this routine is executed at DPC level.
//
// Arguments: [pDevice] -- Our device object.
// [Irp] -- The Irp being completed.
// [IrpContext] -- Context associated with Irp.
//
// Returns: STATUS_MORE_PROCESSING_REQUIRED. Either the posted routine
// or DfsPassThroughRelativeOpen must complete the IRP for real.
//
//-----------------------------------------------------------------------------
NTSTATUSDfsCompleteRelativeOpen( IN PDEVICE_OBJECT pDevice, IN PIRP Irp, IN PIRP_CONTEXT IrpContext){
DfsDbgTrace( +1, Dbg, "DfsCompleteRelativeOpen: Entered\n", 0);
//
// We are only interested in the case when the pass through of relative
// opens returned STATUS_PENDING. In that case, the original thread has
// popped all the way back to the caller of NtCreateFile, and we need
// to finish the open in an asynchronous manner.
//
if (Irp->PendingReturned) {
DfsDbgTrace(0, Dbg, "Pending returned : Queuing DfsRestartRelativeOpen\n", 0);
//
// We need to call IpMarkIrpPending so the IoSubsystem will realize
// that our FSD routine returned STATUS_PENDING. We can't call this
// from the FSD routine itself because the FSD routine doesn't have
// access to the stack location when the underlying guy returns
// STATUS_PENDING
//
IoMarkIrpPending( Irp );
ExInitializeWorkItem( &(IrpContext->WorkQueueItem), DfsRestartRelativeOpen, (PVOID) IrpContext );
ExQueueWorkItem( &IrpContext->WorkQueueItem, CriticalWorkQueue );
}
//
// We MUST return STATUS_MORE_PROCESSING_REQUIRED to halt the completion
// of the Irp. Either DfsRestartRelativeOpen that we queued above or
// DfsPassThroughRelativeOpen will complete the IRP after it is done.
//
DfsDbgTrace(-1, Dbg, "DfsCompleteRelativeOpen: Exited\n", 0);
return( STATUS_MORE_PROCESSING_REQUIRED );
}
//+----------------------------------------------------------------------------
//
// Function: DfsPostProcessRelativeOpen
//
// Synopsis: Continues a relative open after it has already been passed
// to the device of the parent. One of three things could have
// happened -
//
// a) The device of the parent successfully handled the open.
// We create an fcb and return.
// b) The device of the parent could not do the open for some
// reason other than STATUS_DFS_EXIT_PATH_FOUND. We return
// the error to the caller.
// c) The device of the parent returned STATUS_DFS_EXIT_PATH
// found. In that case, we convert the relative open to an
// absolute open and do a full Dnr.
//
// Arguments: [Irp] -- Pointer to Irp
// [IrpContext] -- Pointer to IrpContext associated with Irp
// [Fcb] -- Preallocated Fcb of this file.
//
// Returns:
//
//-----------------------------------------------------------------------------
NTSTATUSDfsPostProcessRelativeOpen( IN PIRP Irp, IN PIRP_CONTEXT IrpContext, IN PDFS_FCB Fcb){ NTSTATUS Status; PIO_STACK_LOCATION IrpSp; PFILE_OBJECT FileObject; UNICODE_STRING NewFileName; BOOLEAN fCompleteRequest = TRUE;
DfsDbgTrace(+1, Dbg, "DfsPostProcessRelativeOpen: Entered\n", 0);
ASSERT( ARGUMENT_PRESENT( Irp ) ); ASSERT( ARGUMENT_PRESENT( IrpContext ) ); ASSERT( ARGUMENT_PRESENT( Fcb ) );
IrpSp = IoGetCurrentIrpStackLocation( Irp );
FileObject = IrpSp->FileObject;
ASSERT( Fcb->Vcb != NULL ); ASSERT( NodeType(Fcb->Vcb) == DSFS_NTC_VCB );
Status = Irp->IoStatus.Status;
if (Status == STATUS_SUCCESS) {
//
// Just set the DFS_FCB for the FileObject.
//
DfsDbgTrace( 0, Dbg, "Relative Open pass through succeeded\n", 0 );
DfsDbgTrace(0, Dbg, "Fcb = %08lx\n", Fcb);
InterlockedIncrement(&Fcb->DfsMachineEntry->UseCount);
//
// Now that a File Open has succeeded, we need to bump up OpenCnt
// on the DFS_VCB.
//
InterlockedIncrement(&Fcb->Vcb->OpenFileCount);
} else if ( Status == STATUS_DFS_EXIT_PATH_FOUND || Status == STATUS_PATH_NOT_COVERED ) {
PDFS_VCB Vcb;
//
// Exit path was found. We'll have to convert this relative open to
// an absolute open, and do a normal dnr on it.
//
DfsDbgTrace(0, Dbg, "Exit point found! Trying absolute open\n", 0);
Vcb = Fcb->Vcb;
NewFileName.Buffer = ExAllocatePoolWithTag( NonPagedPool, Fcb->FullFileName.MaximumLength, ' puM');
if (NewFileName.Buffer != NULL) {
NewFileName.Length = Fcb->FullFileName.Length; NewFileName.MaximumLength = Fcb->FullFileName.MaximumLength;
RtlMoveMemory( (PVOID) NewFileName.Buffer, (PVOID) Fcb->FullFileName.Buffer, Fcb->FullFileName.Length );
DfsDetachFcb( FileObject, Fcb );
DfsDeleteFcb( IrpContext, Fcb );
if (FileObject->FileName.Buffer) {
ExFreePool( FileObject->FileName.Buffer );
}
FileObject->FileName = NewFileName;
// OFS apparently sets the FileObject->Vpb even though it failed
// the open. Reset it to NULL.
//
if (FileObject->Vpb != NULL) { FileObject->Vpb = NULL; }
DfsDbgTrace(0, Dbg, "Absolute path == %wZ\n", &NewFileName);
fCompleteRequest = FALSE;
ASSERT( Vcb != NULL );
Status = DnrStartNameResolution( IrpContext, Irp, Vcb );
} else {
DfsDetachFcb( FileObject, Fcb );
DfsDeleteFcb( IrpContext, Fcb );
Status = STATUS_INSUFFICIENT_RESOURCES;
DfsDbgTrace(0, Dbg, "Unable to allocate full name!\n", 0);
}
} else {
DfsDetachFcb( FileObject, Fcb ); DfsDeleteFcb( IrpContext, Fcb );
}
if (fCompleteRequest) {
DfsCompleteRequest( IrpContext, Irp, Status );
}
DfsDbgTrace(-1, Dbg, "DfsPostProcessRelativeOpen: Exited %08lx\n", ULongToPtr(Status));
return(Status);
}
//+----------------------------------------------------------------------------
//
// Function: DfsRestartRelativeOpen
//
// Synopsis: This function is intended to be queued to complete processing
// of a relative open IRP that was passed through and originally
// came back with STATUS_PENDING.
//
// Arguments: [IrpContext]
//
// Returns: Nothing
//
//-----------------------------------------------------------------------------
VOIDDfsRestartRelativeOpen( IN PIRP_CONTEXT IrpContext){ NTSTATUS Status;
DfsDbgTrace(+1, Dbg, "DfsRestartRelativeOpen: Entered IrpContext == %08lx\n", IrpContext);
Status = DfsPostProcessRelativeOpen( IrpContext->OriginatingIrp, IrpContext, (PDFS_FCB) IrpContext->Context);
DfsDbgTrace(-1, Dbg, "DfsRestartRelativeOpen: Exited\n", 0);
}
//+----------------------------------------------------------------------------
//
// Function: DfsComposeFullName
//
// Synopsis: Given a fully qualified name and a relative name, this
// function allocates room for the concatenation of the two, and
// fills up the buffer with the concatenated name.
//
// Arguments: [ParentName] -- Pointer to fully qualified parent name.
// [RelativeName] -- Pointer to name relative to parent.
// [FullName] -- Pointer to UNICODE_STRING structure that will
// get filled up with the full name.
//
// Returns: STATUS_INSUFFICIENT_RESOURCES if memory allocation fails.
// STAUS_SUCCESS otherwise.
//
// Notes: This routine uses an appropriate allocator so that the
// returned FullName can be put into a FILE_OBJECT.
//
//-----------------------------------------------------------------------------
NTSTATUSDfsComposeFullName( IN PUNICODE_STRING ParentName, IN PUNICODE_STRING RelativeName, OUT PUNICODE_STRING FullName){ ULONG nameLen; NTSTATUS status;
nameLen = ParentName->Length + sizeof (WCHAR) + // For backslash
RelativeName->Length;
if (nameLen > MAXUSHORT) { status = STATUS_NAME_TOO_LONG; MUP_TRACE_HIGH(ERROR, DfsComposeFullName_Error1, LOGUSTR(*ParentName) LOGSTATUS(status)); return status; }
FullName->Buffer = (PWCHAR) ExAllocatePoolWithTag( NonPagedPool, nameLen, ' puM');
if (FullName->Buffer == NULL) { return (STATUS_INSUFFICIENT_RESOURCES); }
FullName->Length = ParentName->Length; FullName->MaximumLength = (USHORT)nameLen; RtlMoveMemory (FullName->Buffer, ParentName->Buffer, ParentName->Length);
if (RelativeName->Length > 0) { (void) DnrConcatenateFilePath( FullName, RelativeName->Buffer, RelativeName->Length); }
return( STATUS_SUCCESS );}
//+----------------------------------------------------------------------------
//
// Function: DfsAreFilesOnSameLocalVolume
//
// Synopsis: Given a file name and a name relative to it, this routine
// will determine if both files live on the same local volume.
//
// Arguments: [ParentName] -- The name of the parent file.
// [FileName] -- Name relative to parent of the other file.
//
// Returns: [STATUS_SUCCESS] -- The two files should indeed be on the
// same local volume.
//
// [STATUS_NOT_SAME_DEVICE] -- The two files are not on the
// same local volume.
//
// [STATUS_OBJECT_TYPE_MISMATCH] -- ustrParentName is not on
// a local volume.
//
//-----------------------------------------------------------------------------
NTSTATUSDfsAreFilesOnSameLocalVolume( IN PUNICODE_STRING ParentName, IN PUNICODE_STRING FileName){ NTSTATUS status = STATUS_SUCCESS; PDFS_PKT pkt; PDFS_PKT_ENTRY pktEntryParent; PDFS_PKT_ENTRY pktEntryFile; UNICODE_STRING remPath; BOOLEAN pktLocked;
DfsDbgTrace(+1, Dbg, "DfsAreFilesOnSameLocalVolume entered\n", 0);
DfsDbgTrace(0, Dbg, "Parent = [%wZ]\n", ParentName); DfsDbgTrace(0, Dbg, "File = [%wZ]\n", FileName);
pkt = _GetPkt();
PktAcquireShared( TRUE, &pktLocked );
//
// First, see if the parent is on a local volume at all.
//
pktEntryParent = PktLookupEntryByPrefix( pkt, ParentName, &remPath );
DfsDbgTrace(0, Dbg, "Parent Entry @%08lx\n", pktEntryParent);
if (pktEntryParent == NULL || !(pktEntryParent->Type & PKT_ENTRY_TYPE_LOCAL)) {
status = STATUS_OBJECT_TYPE_MISMATCH;
}
if (NT_SUCCESS(status)) {
USHORT parentLen;
//
// Parent is local, verify that the relative file does not cross a
// junction point. We'll iterate through the list of exit points on
// the parent's local volume pkt entry, comparing the remaing path
// of the exit point with the FileName argument
//
ASSERT(pktEntryParent != NULL);
parentLen = pktEntryParent->Id.Prefix.Length + sizeof(UNICODE_PATH_SEP);
for (pktEntryFile = PktEntryFirstSubordinate(pktEntryParent); pktEntryFile != NULL && NT_SUCCESS(status); pktEntryFile = PktEntryNextSubordinate( pktEntryParent, pktEntryFile)) {
remPath = pktEntryFile->Id.Prefix; remPath.Length -= parentLen; remPath.Buffer += (parentLen/sizeof(WCHAR));
if (DfsRtlPrefixPath( &remPath, FileName, FALSE)) {
DfsDbgTrace(0, Dbg, "Found entry %08lx for File\n", pktEntryFile);
//
// FileName is on another volume.
//
status = STATUS_NOT_SAME_DEVICE;
}
}
}
PktRelease();
DfsDbgTrace(-1, Dbg, "DfsAreFilesOnSameLocalVolume exit %08lx\n", ULongToPtr(status));
return( status );}
|
