1327 lines
40 KiB
C
1327 lines
40 KiB
C
//+----------------------------------------------------------------------------
|
||
//
|
||
// 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
|
||
//
|
||
|
||
NTSTATUS
|
||
DfsCommonCreate (
|
||
OPTIONAL IN PIRP_CONTEXT IrpContext,
|
||
PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp);
|
||
|
||
IO_STATUS_BLOCK
|
||
DfsOpenDevice (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PFILE_OBJECT FileObject,
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN ACCESS_MASK DesiredAccess,
|
||
IN USHORT ShareAccess,
|
||
IN ULONG CreateOptions);
|
||
|
||
NTSTATUS
|
||
DfsPassThroughRelativeOpen(
|
||
IN PIRP Irp,
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PDFS_FCB ParentFcb);
|
||
|
||
NTSTATUS
|
||
DfsCompleteRelativeOpen(
|
||
IN PDEVICE_OBJECT pDevice,
|
||
IN PIRP Irp,
|
||
IN PVOID Context);
|
||
|
||
NTSTATUS
|
||
DfsPostProcessRelativeOpen(
|
||
IN PIRP Irp,
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PDFS_FCB ParentFcb);
|
||
|
||
VOID
|
||
DfsRestartRelativeOpen(
|
||
IN PIRP_CONTEXT IrpContext);
|
||
|
||
NTSTATUS
|
||
DfsComposeFullName(
|
||
IN PUNICODE_STRING ParentName,
|
||
IN PUNICODE_STRING RelativeName,
|
||
OUT PUNICODE_STRING FullName);
|
||
|
||
NTSTATUS
|
||
DfsAreFilesOnSameLocalVolume(
|
||
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
|
||
//
|
||
//--------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
DfsFsdCreate (
|
||
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
|
||
//
|
||
//--------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
DfsCommonCreate (
|
||
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_BLOCK
|
||
DfsOpenDevice (
|
||
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.
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
DfsPassThroughRelativeOpen(
|
||
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.
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
DfsCompleteRelativeOpen(
|
||
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:
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
DfsPostProcessRelativeOpen(
|
||
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
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
|
||
VOID
|
||
DfsRestartRelativeOpen(
|
||
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.
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
DfsComposeFullName(
|
||
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.
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
DfsAreFilesOnSameLocalVolume(
|
||
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 );
|
||
}
|
||
|