548 lines
15 KiB
C
548 lines
15 KiB
C
//+----------------------------------------------------------------------------
|
||
//
|
||
// Copyright (C) 1996, Microsoft Corporation
|
||
//
|
||
// File: create.c
|
||
//
|
||
// Contents: Implements the Create code for the Dfs server. The Dfs server
|
||
// only allows opening the File System Device object for the
|
||
// express purpose of FsControlling to the Dfs server.
|
||
//
|
||
// Classes:
|
||
//
|
||
// Functions: DfsFsdCreate
|
||
// DfsOpenDevice
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
|
||
#include "dfsprocs.h"
|
||
#include "attach.h"
|
||
#include "dfswml.h"
|
||
|
||
//
|
||
// The debug trace level
|
||
//
|
||
|
||
#define Dbg (DEBUG_TRACE_CREATE)
|
||
|
||
//
|
||
// Local procedure prototypes
|
||
//
|
||
|
||
NTSTATUS
|
||
DfsOpenFile(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp);
|
||
|
||
NTSTATUS
|
||
DfsCompleteOpenFile(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN PVOID Context);
|
||
|
||
NTSTATUS
|
||
DfsOpenDevice (
|
||
IN PFILE_OBJECT FileObject,
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN ULONG CreateOptions);
|
||
|
||
VOID
|
||
DfspDoesPathCrossJunctionPoint(
|
||
IN PUNICODE_STRING Path,
|
||
OUT BOOLEAN *IsExitPoint,
|
||
OUT BOOLEAN *CrossesExitPoint);
|
||
|
||
#ifdef ALLOC_PRAGMA
|
||
|
||
#pragma alloc_text( PAGE, DfsFsdCreate )
|
||
#pragma alloc_text( PAGE, DfsOpenFile )
|
||
#pragma alloc_text( PAGE, DfsOpenDevice )
|
||
|
||
#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 relative to which
|
||
// the open is to be processed.
|
||
// [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;
|
||
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
|
||
PFILE_OBJECT FileObject = irpSp->FileObject;
|
||
PFILE_OBJECT fileObject;
|
||
ULONG createOptions;
|
||
|
||
DebugTrace(+1, Dbg, "DfsFsdCreate: Entered\n", 0);
|
||
DFS_TRACE_HIGH(TRACE_IRP, DfsFsdCreate_Entry,
|
||
LOGPTR(DeviceObject)
|
||
LOGPTR(FileObject)
|
||
LOGUSTR(FileObject->FileName)
|
||
LOGPTR(Irp));
|
||
|
||
ASSERT(IoIsOperationSynchronous(Irp) == TRUE);
|
||
|
||
//
|
||
// If someone is coming in via a device object attached to a file system
|
||
// device object, pass it through.
|
||
//
|
||
|
||
if (DeviceObject->DeviceType == FILE_DEVICE_DISK_FILE_SYSTEM) {
|
||
|
||
status = DfsVolumePassThrough(DeviceObject, Irp);
|
||
|
||
DebugTrace(-1, Dbg, "DfsFsdCreate: FS Device Pass Through Exit %08lx\n", ULongToPtr( status ));
|
||
|
||
return status;
|
||
|
||
}
|
||
|
||
//
|
||
// If someone is coming in via a device object attached to a file system
|
||
// volume, we need to see if they are opening an exit point via its local
|
||
// file system name.
|
||
//
|
||
|
||
if (DeviceObject->DeviceType == FILE_DEVICE_DFS_VOLUME) {
|
||
|
||
if (((PDFS_VOLUME_OBJECT)DeviceObject)->DfsEnable == TRUE) {
|
||
status = DfsOpenFile(DeviceObject, Irp);
|
||
|
||
DebugTrace(-1, Dbg, "DfsFsdCreate: Local File Open Exit %08lx\n", ULongToPtr( status ));
|
||
}
|
||
else {
|
||
status = DfsVolumePassThrough(DeviceObject, Irp);
|
||
|
||
DebugTrace(-1, Dbg, "DfsFsdCreate: (DfsDisable) FS Device Pass Through Exit %08lx\n", ULongToPtr( status ));
|
||
|
||
}
|
||
return status;
|
||
}
|
||
|
||
//
|
||
// The only other create we handle is someone trying to open our own
|
||
// file system device object.
|
||
//
|
||
|
||
ASSERT(DeviceObject->DeviceType == FILE_DEVICE_DFS_FILE_SYSTEM);
|
||
|
||
FsRtlEnterFileSystem();
|
||
|
||
fileObject = irpSp->FileObject;
|
||
createOptions = irpSp->Parameters.Create.Options;
|
||
|
||
if (fileObject->FileName.Length == 0 &&
|
||
fileObject->RelatedFileObject == NULL) {
|
||
|
||
//
|
||
// This is the only case we handle
|
||
//
|
||
|
||
status = DfsOpenDevice(
|
||
fileObject,
|
||
DeviceObject,
|
||
createOptions);
|
||
|
||
} else {
|
||
|
||
status = STATUS_INVALID_DEVICE_REQUEST;
|
||
|
||
}
|
||
|
||
FsRtlExitFileSystem();
|
||
|
||
//
|
||
// And return to our caller
|
||
//
|
||
|
||
DebugTrace(-1, Dbg, "DfsFsdCreate: Exit -> %08lx\n", ULongToPtr( status ));
|
||
|
||
DfsCompleteRequest( Irp, status );
|
||
|
||
DFS_TRACE_HIGH(TRACE_IRP, DfsFsdCreate_Exit,
|
||
LOGSTATUS(status)
|
||
LOGPTR(fileObject)
|
||
LOGPTR(Irp));
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
//+----------------------------------------------------------------------------
|
||
//
|
||
// Function: DfsOpenFile, local
|
||
//
|
||
// Synopsis: This routine handles file opens that come in via attached
|
||
// volumes. The semantics of this open are:
|
||
//
|
||
// If the named file is a child of a DfsExitPath, fail it
|
||
// with access denied.
|
||
//
|
||
// If the named file is a DfsExitPath, and CreateOptions specify
|
||
// DELETE_ON_CLOSE, fail it with access denied.
|
||
//
|
||
// In all other cases, allocate an FCB, and pass the open through
|
||
// to the underlying FS. If the open succeeds, then insert the
|
||
// FCB in our FCB table. If the open fails, destroy the FCB.
|
||
//
|
||
// Arguments: [DeviceObject] -- The attached device object through which
|
||
// the Create Irp came in.
|
||
//
|
||
// [Irp] -- The Create Irp.
|
||
//
|
||
// Returns: [STATUS_INSUFFICIENT_RESOURCES] -- Unable to allocate an FCB.
|
||
//
|
||
// [STATUS_ACCESS_DENIED] -- The file is a child of a Dfs exit
|
||
// path or the file is a Dfs exit path and
|
||
// DELETE_ON_CLOSE was specified.
|
||
//
|
||
// Status from the underlying FS.
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
DfsOpenFile(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp)
|
||
{
|
||
NTSTATUS status;
|
||
|
||
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
|
||
PIO_STACK_LOCATION nextIrpSp;
|
||
PFILE_OBJECT fileObject = irpSp->FileObject;
|
||
ULONG createOptions = irpSp->Parameters.Create.Options;
|
||
PDFS_FCB fcb = NULL;
|
||
|
||
DebugTrace(+1, Dbg, "DfsOpenFile - Entered\n", 0);
|
||
DFS_TRACE_LOW(TRACE_IRP, DfsOpenFile_Entry,
|
||
LOGPTR(fileObject)
|
||
LOGPTR(Irp));
|
||
|
||
//
|
||
// Optimistically, we allocate an FCB for this open.
|
||
//
|
||
|
||
status = DfsAllocateFcb(DeviceObject, fileObject, &fcb);
|
||
|
||
if (NT_SUCCESS(status)) {
|
||
|
||
BOOLEAN isExitPoint, crossesExitPoint;
|
||
|
||
DfspDoesPathCrossJunctionPoint(
|
||
&fcb->FullFileName,
|
||
&isExitPoint,
|
||
&crossesExitPoint);
|
||
|
||
if (isExitPoint && (createOptions & FILE_DELETE_ON_CLOSE))
|
||
status = STATUS_ACCESS_DENIED;
|
||
|
||
if (crossesExitPoint)
|
||
status = STATUS_ACCESS_DENIED;
|
||
}
|
||
|
||
//
|
||
// If we haven't failed yet, we need to pass this open down to the
|
||
// underlying file system. If we failed, then we need to complete the
|
||
// Create Irp.
|
||
//
|
||
|
||
if (NT_SUCCESS(status)) {
|
||
|
||
PDEVICE_OBJECT vdo;
|
||
|
||
//
|
||
// Copy the stack from one to the next...
|
||
//
|
||
|
||
nextIrpSp = IoGetNextIrpStackLocation(Irp);
|
||
|
||
(*nextIrpSp) = (*irpSp);
|
||
|
||
IoSetCompletionRoutine(
|
||
Irp,
|
||
DfsCompleteOpenFile,
|
||
(PVOID) fcb,
|
||
TRUE,
|
||
TRUE,
|
||
TRUE);
|
||
|
||
//
|
||
// Find out what device to call...and call it
|
||
//
|
||
|
||
vdo = ((PDFS_VOLUME_OBJECT) DeviceObject)->Provider.DeviceObject;
|
||
|
||
status = IoCallDriver( vdo, Irp );
|
||
DFS_TRACE_ERROR_HIGH(status, ALL_ERROR, DfsOpenFile_Error_IoCallDriver,
|
||
LOGSTATUS(status)
|
||
LOGPTR(fileObject)
|
||
LOGPTR(Irp));
|
||
|
||
|
||
} else {
|
||
|
||
if (fcb != NULL) {
|
||
|
||
DfsDestroyFcb(fcb);
|
||
|
||
}
|
||
|
||
DfsCompleteRequest( Irp, status );
|
||
|
||
}
|
||
|
||
DebugTrace(-1, Dbg, "DfsOpenFile - Exited %08lx\n", ULongToPtr( status ));
|
||
DFS_TRACE_LOW(TRACE_IRP, DfsOpenFile_Exit,
|
||
LOGSTATUS(status)
|
||
LOGPTR(fileObject)
|
||
LOGPTR(Irp));
|
||
|
||
return( status );
|
||
|
||
}
|
||
|
||
|
||
//+----------------------------------------------------------------------------
|
||
//
|
||
// Function: DfsCompleteOpenFile, local
|
||
//
|
||
// Synopsis: Completion routine for DfsOpenFile. If the underlying FS
|
||
// successfully opened the file, we insert the FCB into our
|
||
// FCB table, else we destroy the preallocated FCB.
|
||
//
|
||
// Arguments: [DeviceObject] -- Our device object, unused.
|
||
//
|
||
// [Irp] -- The Create Irp that is being completed, unused.
|
||
//
|
||
// [Context] -- Actually, a pointer to our pre-allocated FCB
|
||
//
|
||
// Returns: [STATUS_SUCCESS] -- This function always succeeds.
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
DfsCompleteOpenFile(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN PVOID Context)
|
||
{
|
||
PDFS_FCB fcb = (PDFS_FCB) Context;
|
||
|
||
if (Irp->PendingReturned) {
|
||
|
||
//
|
||
// 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 );
|
||
|
||
}
|
||
|
||
if (Irp->IoStatus.Status == STATUS_SUCCESS) {
|
||
|
||
DfsAttachFcb( fcb->FileObject, fcb );
|
||
|
||
} else {
|
||
|
||
DfsDestroyFcb( fcb );
|
||
}
|
||
|
||
return( STATUS_SUCCESS );
|
||
}
|
||
|
||
|
||
//+-------------------------------------------------------------------
|
||
//
|
||
// 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
|
||
// [CreateOptions] - Supplies the create options for
|
||
// this operation
|
||
//
|
||
// Returns: [IO_STATUS_BLOCK] - Returns the completion status for
|
||
// the operation
|
||
//
|
||
//--------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
DfsOpenDevice (
|
||
IN PFILE_OBJECT FileObject,
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN ULONG CreateOptions
|
||
) {
|
||
NTSTATUS status;
|
||
//
|
||
// Check to see which type of device is being opened.
|
||
// We don't permit all open modes on the file system
|
||
// device object.
|
||
//
|
||
|
||
ULONG CreateDisposition = (CreateOptions >> 24) & 0x000000ff;
|
||
DFS_TRACE_LOW(TRACE_IRP, DfsOpenDevice_Entry,
|
||
LOGPTR(FileObject)
|
||
LOGPTR(DeviceObject)
|
||
LOGULONG(CreateOptions));
|
||
|
||
//
|
||
// Check for proper desired access and rights
|
||
//
|
||
|
||
if (CreateDisposition != FILE_OPEN
|
||
&& CreateDisposition != FILE_OPEN_IF ) {
|
||
status = STATUS_ACCESS_DENIED;
|
||
DebugTrace(0, Dbg,
|
||
"DfsOpenDevice: Invalid CreateDisposition\n", 0);
|
||
|
||
DFS_TRACE_HIGH(ERROR, DfsOpenDevice_Error1,
|
||
LOGSTATUS(status)
|
||
LOGPTR(FileObject)
|
||
LOGPTR(DeviceObject));
|
||
return( status );
|
||
}
|
||
|
||
//
|
||
// Check if we were to open a directory
|
||
//
|
||
|
||
if (CreateOptions & FILE_DIRECTORY_FILE) {
|
||
status = STATUS_NOT_A_DIRECTORY;
|
||
DebugTrace(0, Dbg,
|
||
"DfsOpenDevice: Cannot open device as a directory\n", 0);
|
||
|
||
DFS_TRACE_HIGH(ERROR, DfsOpenDevice_Error3,
|
||
LOGSTATUS(status)
|
||
LOGPTR(FileObject)
|
||
LOGPTR(DeviceObject));
|
||
return( status );
|
||
|
||
}
|
||
|
||
FileObject->FsContext = UIntToPtr( DFS_OPEN_CONTEXT );
|
||
status = STATUS_SUCCESS;
|
||
DFS_TRACE_LOW(TRACE_IRP, DfsOpenDevice_Exit,
|
||
LOGSTATUS(status)
|
||
LOGPTR(FileObject)
|
||
LOGPTR(DeviceObject));
|
||
return( status );
|
||
}
|
||
|
||
|
||
//+----------------------------------------------------------------------------
|
||
//
|
||
// Function: DfspDoesPathCrossJunctionPoint
|
||
//
|
||
// Synopsis: Given a fully formed local FS path
|
||
// (looks like "\DosDevices\C:\foo\bar") this routine figures out
|
||
// if the path matches an exit point exactly, or crosses an
|
||
// exit point.
|
||
//
|
||
// Arguments: [Path] -- The path to check.
|
||
// [IsExitPoint] -- The path refers to an exit point.
|
||
// [CrossesExitPoint] -- The path crosses an exit point.
|
||
//
|
||
// Returns: NOTHING. The results are returned in the two out parameters.
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
|
||
VOID
|
||
DfspDoesPathCrossJunctionPoint(
|
||
IN PUNICODE_STRING Path,
|
||
OUT BOOLEAN *IsExitPoint,
|
||
OUT BOOLEAN *CrossesExitPoint)
|
||
{
|
||
PDFS_PKT pkt;
|
||
PDFS_LOCAL_VOL_ENTRY lv;
|
||
UNICODE_STRING remPath;
|
||
|
||
*IsExitPoint = FALSE;
|
||
*CrossesExitPoint = FALSE;
|
||
|
||
pkt = _GetPkt();
|
||
|
||
PktAcquireShared(pkt, TRUE);
|
||
|
||
lv = PktEntryLookupLocalService(pkt, Path, &remPath);
|
||
|
||
if (lv != NULL && remPath.Length != 0) {
|
||
|
||
PDFS_PKT_ENTRY pktEntry, pktExitEntry;
|
||
USHORT prefixLength;
|
||
UNICODE_STRING remExitPt;
|
||
PUNICODE_STRING exitPrefix;
|
||
|
||
pktEntry = lv->PktEntry;
|
||
prefixLength = pktEntry->Id.Prefix.Length;
|
||
pktExitEntry = PktEntryFirstSubordinate(pktEntry);
|
||
|
||
//
|
||
// As long as there are more exit points see if the path crosses
|
||
// the exit point.
|
||
//
|
||
|
||
while (pktExitEntry != NULL &&
|
||
!(*IsExitPoint) &&
|
||
!(*CrossesExitPoint)) {
|
||
|
||
exitPrefix = &pktExitEntry->Id.Prefix;
|
||
|
||
if (exitPrefix->Buffer[prefixLength/sizeof(WCHAR)] == UNICODE_PATH_SEP)
|
||
prefixLength += sizeof(WCHAR);
|
||
|
||
remExitPt.Length = pktExitEntry->Id.Prefix.Length - prefixLength;
|
||
remExitPt.MaximumLength = remExitPt.Length + 1;
|
||
remExitPt.Buffer = &exitPrefix->Buffer[prefixLength/sizeof(WCHAR)];
|
||
|
||
//
|
||
// If the Path has the potential of crossing past the junction
|
||
// point, we have something to return!
|
||
//
|
||
|
||
if (DfsRtlPrefixPath(&remExitPt, &remPath, TRUE)) {
|
||
|
||
if (remExitPt.Length == remPath.Length) {
|
||
|
||
*IsExitPoint = TRUE;
|
||
|
||
} else {
|
||
|
||
*CrossesExitPoint = TRUE;
|
||
|
||
}
|
||
}
|
||
|
||
pktExitEntry = PktEntryNextSubordinate(pktEntry, pktExitEntry);
|
||
|
||
} //while exit pt exists
|
||
|
||
} // lv != NULL && remPath.Length != 0
|
||
|
||
PktRelease(pkt);
|
||
|
||
}
|
||
|