mirror of
https://github.com/reactos/reactos.git
synced 2024-12-29 10:35:28 +00:00
c40b0866b1
Some places have been changed to return FILE_DOES_NOT_EXIST, everything else just returns 0. FastFAT driver from MS does the same (tm), so I'm not going to have a big research here. CORE-16623 Co-authored-by: Suraj K Suresh <kssuraj15@gmail.com>
2583 lines
111 KiB
C++
2583 lines
111 KiB
C++
////////////////////////////////////////////////////////////////////
|
|
// Copyright (C) Alexander Telyatnikov, Ivan Keliukh, Yegor Anchishkin, SKIF Software, 1999-2013. Kiev, Ukraine
|
|
// All rights reserved
|
|
// This file was released under the GPLv2 on June 2015.
|
|
////////////////////////////////////////////////////////////////////
|
|
/*************************************************************************
|
|
*
|
|
* File: Create.cpp
|
|
*
|
|
* Module: UDF File System Driver (Kernel mode execution only)
|
|
*
|
|
* Description:
|
|
* Contains code to handle the "Create"/"Open" dispatch entry point.
|
|
*
|
|
*************************************************************************/
|
|
|
|
#include "udffs.h"
|
|
|
|
#define IsFileObjectReadOnly(FO) (!((FO)->WriteAccess | (FO)->DeleteAccess))
|
|
|
|
// define the file specific bug-check id
|
|
#define UDF_BUG_CHECK_ID UDF_FILE_CREATE
|
|
|
|
#define MEM_USABS_TAG "US_Abs"
|
|
#define MEM_USLOC_TAG "US_Loc"
|
|
#define MEM_USOBJ_TAG "US_Obj"
|
|
|
|
#define UDF_LOG_CREATE_DISPOSITION
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFCreate()
|
|
*
|
|
* Description:
|
|
* The I/O Manager will invoke this routine to handle a create/open
|
|
* request
|
|
*
|
|
* Expected Interrupt Level (for execution) :
|
|
*
|
|
* IRQL_PASSIVE_LEVEL (invocation at higher IRQL will cause execution
|
|
* to be deferred to a worker thread context)
|
|
*
|
|
* Return Value: STATUS_SUCCESS/Error
|
|
*
|
|
*************************************************************************/
|
|
NTSTATUS
|
|
NTAPI
|
|
UDFCreate(
|
|
PDEVICE_OBJECT DeviceObject, // the logical volume device object
|
|
PIRP Irp) // I/O Request Packet
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PtrUDFIrpContext PtrIrpContext;
|
|
BOOLEAN AreWeTopLevel = FALSE;
|
|
|
|
TmPrint(("UDFCreate:\n"));
|
|
|
|
FsRtlEnterFileSystem();
|
|
ASSERT(DeviceObject);
|
|
ASSERT(Irp);
|
|
|
|
// sometimes, we may be called here with the device object representing
|
|
// the file system (instead of the device object created for a logical
|
|
// volume. In this case, there is not much we wish to do (this create
|
|
// typically will happen 'cause some process has to open the FSD device
|
|
// object so as to be able to send an IOCTL to the FSD)
|
|
|
|
// All of the logical volume device objects we create have a device
|
|
// extension whereas the device object representing the FSD has no
|
|
// device extension. This seems like a good enough method to identify
|
|
// between the two device objects ...
|
|
if (UDFIsFSDevObj(DeviceObject)) {
|
|
// this is an open of the FSD itself
|
|
Irp->IoStatus.Status = RC;
|
|
Irp->IoStatus.Information = FILE_OPENED;
|
|
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
FsRtlExitFileSystem();
|
|
return(RC);
|
|
}
|
|
|
|
// set the top level context
|
|
AreWeTopLevel = UDFIsIrpTopLevel(Irp);
|
|
|
|
_SEH2_TRY {
|
|
|
|
// get an IRP context structure and issue the request
|
|
PtrIrpContext = UDFAllocateIrpContext(Irp, DeviceObject);
|
|
if(PtrIrpContext) {
|
|
RC = UDFCommonCreate(PtrIrpContext, Irp);
|
|
} else {
|
|
RC = STATUS_INSUFFICIENT_RESOURCES;
|
|
Irp->IoStatus.Status = RC;
|
|
Irp->IoStatus.Information = 0;
|
|
// complete the IRP
|
|
IoCompleteRequest(Irp, IO_DISK_INCREMENT);
|
|
}
|
|
|
|
} _SEH2_EXCEPT(UDFExceptionFilter(PtrIrpContext, _SEH2_GetExceptionInformation())) {
|
|
|
|
RC = UDFExceptionHandler(PtrIrpContext, Irp);
|
|
|
|
UDFLogEvent(UDF_ERROR_INTERNAL_ERROR, RC);
|
|
} _SEH2_END;
|
|
|
|
if (AreWeTopLevel) {
|
|
IoSetTopLevelIrp(NULL);
|
|
}
|
|
|
|
AdPrint(("UDFCreate: %x\n", RC));
|
|
|
|
FsRtlExitFileSystem();
|
|
|
|
return(RC);
|
|
|
|
} // end UDFCreate()
|
|
|
|
/*
|
|
*/
|
|
VOID
|
|
__fastcall
|
|
UDFReleaseResFromCreate(
|
|
IN PERESOURCE* PagingIoRes,
|
|
IN PERESOURCE* Res1,
|
|
IN PERESOURCE* Res2
|
|
)
|
|
{
|
|
if(*PagingIoRes) {
|
|
UDFReleaseResource(*PagingIoRes);
|
|
(*PagingIoRes) = NULL;
|
|
}
|
|
if(*Res1) {
|
|
UDFReleaseResource(*Res1);
|
|
(*Res1) = NULL;
|
|
}
|
|
if(*Res2) {
|
|
UDFReleaseResource(*Res2);
|
|
(*Res2) = NULL;
|
|
}
|
|
} // end UDFReleaseResFromCreate()
|
|
|
|
/*
|
|
*/
|
|
VOID
|
|
__fastcall
|
|
UDFAcquireParent(
|
|
IN PUDF_FILE_INFO RelatedFileInfo,
|
|
IN PERESOURCE* Res1,
|
|
IN PERESOURCE* Res2
|
|
)
|
|
{
|
|
if(RelatedFileInfo->Fcb &&
|
|
RelatedFileInfo->Fcb->ParentFcb) {
|
|
|
|
UDF_CHECK_PAGING_IO_RESOURCE(RelatedFileInfo->Fcb->ParentFcb->NTRequiredFCB);
|
|
UDFAcquireResourceExclusive((*Res2) = &(RelatedFileInfo->Fcb->ParentFcb->NTRequiredFCB->MainResource),TRUE);
|
|
}
|
|
|
|
UDF_CHECK_PAGING_IO_RESOURCE(RelatedFileInfo->Fcb->NTRequiredFCB);
|
|
UDFAcquireResourceExclusive((*Res1) = &(RelatedFileInfo->Fcb->NTRequiredFCB->MainResource),TRUE);
|
|
|
|
UDFInterlockedIncrement((PLONG)&(RelatedFileInfo->Fcb->ReferenceCount));
|
|
UDFInterlockedIncrement((PLONG)&(RelatedFileInfo->Dloc->CommonFcb->CommonRefCount));
|
|
UDFReferenceFile__(RelatedFileInfo);
|
|
ASSERT_REF(RelatedFileInfo->Fcb->ReferenceCount >= RelatedFileInfo->RefCount);
|
|
} // end UDFAcquireParent()
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFCommonCreate()
|
|
*
|
|
* Description:
|
|
* The actual work is performed here. This routine may be invoked in one'
|
|
* of the two possible contexts:
|
|
* (a) in the context of a system worker thread
|
|
* (b) in the context of the original caller
|
|
*
|
|
* Expected Interrupt Level (for execution) :
|
|
*
|
|
* IRQL_PASSIVE_LEVEL
|
|
*
|
|
* Return Value: STATUS_SUCCESS/Error
|
|
*
|
|
*************************************************************************/
|
|
NTSTATUS
|
|
UDFCommonCreate(
|
|
PtrUDFIrpContext PtrIrpContext,
|
|
PIRP Irp
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PIO_STACK_LOCATION IrpSp = NULL;
|
|
PIO_SECURITY_CONTEXT PtrSecurityContext = NULL;
|
|
PFILE_OBJECT PtrNewFileObject = NULL;
|
|
PFILE_OBJECT PtrRelatedFileObject = NULL;
|
|
LONGLONG AllocationSize; // if we create a new file
|
|
PFILE_FULL_EA_INFORMATION PtrExtAttrBuffer = NULL;
|
|
ULONG RequestedOptions;
|
|
ULONG RequestedDisposition;
|
|
USHORT FileAttributes;
|
|
USHORT TmpFileAttributes;
|
|
USHORT ShareAccess;
|
|
ULONG ExtAttrLength = 0;
|
|
ACCESS_MASK DesiredAccess;
|
|
PACCESS_STATE AccessState;
|
|
|
|
PVCB Vcb = NULL;
|
|
_SEH2_VOLATILE BOOLEAN AcquiredVcb = FALSE;
|
|
BOOLEAN OpenExisting = FALSE;
|
|
PERESOURCE Res1 = NULL;
|
|
PERESOURCE Res2 = NULL;
|
|
PERESOURCE PagingIoRes = NULL;
|
|
|
|
// BOOLEAN DirectoryOnlyRequested;
|
|
// BOOLEAN FileOnlyRequested;
|
|
// BOOLEAN NoBufferingSpecified;
|
|
BOOLEAN WriteThroughRequested;
|
|
BOOLEAN DeleteOnCloseSpecified;
|
|
// BOOLEAN NoExtAttrKnowledge;
|
|
// BOOLEAN CreateTreeConnection = FALSE;
|
|
// BOOLEAN OpenByFileId;
|
|
|
|
// Are we dealing with a page file?
|
|
BOOLEAN PageFileManipulation;
|
|
// Is this open for a target directory (used in rename operations)?
|
|
BOOLEAN OpenTargetDirectory;
|
|
// Should we ignore case when attempting to locate the object?
|
|
BOOLEAN IgnoreCase;
|
|
|
|
PtrUDFCCB PtrRelatedCCB = NULL, PtrNewCcb = NULL;
|
|
PtrUDFFCB PtrRelatedFCB = NULL, PtrNewFcb = NULL;
|
|
PtrUDFNTRequiredFCB NtReqFcb;
|
|
|
|
ULONG ReturnedInformation = 0;
|
|
|
|
UNICODE_STRING TargetObjectName;
|
|
UNICODE_STRING RelatedObjectName;
|
|
|
|
UNICODE_STRING AbsolutePathName; // '\aaa\cdf\fff\rrrr.tre:s'
|
|
UNICODE_STRING LocalPath; // '\aaa\cdf'
|
|
UNICODE_STRING CurName; // 'cdf'
|
|
UNICODE_STRING TailName; // 'fff\rrrr.tre:s'
|
|
UNICODE_STRING LastGoodName; // it depends...
|
|
UNICODE_STRING LastGoodTail; // it depends...
|
|
UNICODE_STRING StreamName; // ':s'
|
|
|
|
PUDF_FILE_INFO RelatedFileInfo;
|
|
PUDF_FILE_INFO OldRelatedFileInfo = NULL;
|
|
PUDF_FILE_INFO NewFileInfo = NULL;
|
|
PUDF_FILE_INFO LastGoodFileInfo = NULL;
|
|
PWCHAR TmpBuffer;
|
|
ULONG TreeLength = 0;
|
|
// ULONG i = 0;
|
|
|
|
BOOLEAN StreamOpen = FALSE;
|
|
BOOLEAN StreamExists = FALSE;
|
|
BOOLEAN RestoreVCBOpenCounter = FALSE;
|
|
BOOLEAN RestoreShareAccess = FALSE;
|
|
PWCHAR TailNameBuffer = NULL;
|
|
ULONG SNameIndex = 0;
|
|
|
|
TmPrint(("UDFCommonCreate:\n"));
|
|
|
|
ASSERT(PtrIrpContext);
|
|
ASSERT(Irp);
|
|
|
|
_SEH2_TRY {
|
|
|
|
AbsolutePathName.Buffer =
|
|
LocalPath.Buffer = NULL;
|
|
// If we were called with our file system device object instead of a
|
|
// volume device object, just complete this request with STATUS_SUCCESS.
|
|
if (!(PtrIrpContext->TargetDeviceObject->DeviceExtension)) {
|
|
|
|
ReturnedInformation = FILE_OPENED;
|
|
try_return(RC = STATUS_SUCCESS);
|
|
}
|
|
|
|
AbsolutePathName.Length = AbsolutePathName.MaximumLength =
|
|
LocalPath.Length = LocalPath.MaximumLength = 0;
|
|
// First, get a pointer to the current I/O stack location
|
|
IrpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
ASSERT(IrpSp);
|
|
|
|
// If the caller cannot block, post the request to be handled
|
|
// asynchronously
|
|
if (!(PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_CAN_BLOCK)) {
|
|
// We must defer processing of this request since we could
|
|
// block anytime while performing the create/open ...
|
|
ASSERT(FALSE);
|
|
RC = UDFPostRequest(PtrIrpContext, Irp);
|
|
try_return(RC);
|
|
}
|
|
|
|
// Now, we can obtain the parameters specified by the user.
|
|
// Note that the file object is the new object created by the
|
|
// I/O Manager in anticipation that this create/open request
|
|
// will succeed.
|
|
PtrNewFileObject = IrpSp->FileObject;
|
|
TargetObjectName = PtrNewFileObject->FileName;
|
|
PtrRelatedFileObject = PtrNewFileObject->RelatedFileObject;
|
|
|
|
// If a related file object is present, get the pointers
|
|
// to the CCB and the FCB for the related file object
|
|
if (PtrRelatedFileObject) {
|
|
PtrRelatedCCB = (PtrUDFCCB)(PtrRelatedFileObject->FsContext2);
|
|
ASSERT(PtrRelatedCCB);
|
|
ASSERT(PtrRelatedCCB->NodeIdentifier.NodeType == UDF_NODE_TYPE_CCB);
|
|
// each CCB in turn points to a FCB
|
|
PtrRelatedFCB = PtrRelatedCCB->Fcb;
|
|
ASSERT(PtrRelatedFCB);
|
|
ASSERT((PtrRelatedFCB->NodeIdentifier.NodeType == UDF_NODE_TYPE_FCB)
|
|
||(PtrRelatedFCB->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB));
|
|
RelatedObjectName = PtrRelatedFileObject->FileName;
|
|
if (!(RelatedObjectName.Length) || (RelatedObjectName.Buffer[0] != L'\\')) {
|
|
if(PtrRelatedFCB->FCBName)
|
|
RelatedObjectName = PtrRelatedFCB->FCBName->ObjectName;
|
|
}
|
|
}
|
|
|
|
// Allocation size is only used if a new file is created
|
|
// or a file is superseded.
|
|
AllocationSize = Irp->Overlay.AllocationSize.QuadPart;
|
|
|
|
// Get a ptr to the supplied security context
|
|
PtrSecurityContext = IrpSp->Parameters.Create.SecurityContext;
|
|
AccessState = PtrSecurityContext->AccessState;
|
|
|
|
// The desired access can be obtained from the SecurityContext
|
|
DesiredAccess = PtrSecurityContext->DesiredAccess;
|
|
|
|
// Two values are supplied in the Create.Options field:
|
|
// (a) the actual user supplied options
|
|
// (b) the create disposition
|
|
RequestedOptions = (IrpSp->Parameters.Create.Options & FILE_VALID_OPTION_FLAGS);
|
|
|
|
// The file disposition is packed with the user options ...
|
|
// Disposition includes FILE_SUPERSEDE, FILE_OPEN_IF, etc.
|
|
RequestedDisposition = (IrpSp->Parameters.Create.Options >> 24);// & 0xFF;
|
|
|
|
//#ifdef UDF_LOG_CREATE_DISPOSITION
|
|
switch(RequestedDisposition) {
|
|
case FILE_SUPERSEDE:
|
|
AdPrint((" Dispos: FILE_SUPERSEDE\n"));
|
|
break;
|
|
case FILE_OPEN:
|
|
AdPrint((" Dispos: FILE_OPEN\n"));
|
|
break;
|
|
case FILE_CREATE:
|
|
AdPrint((" Dispos: FILE_CREATE\n"));
|
|
break;
|
|
case FILE_OPEN_IF:
|
|
AdPrint((" Dispos: FILE_OPEN_IF\n"));
|
|
break;
|
|
case FILE_OVERWRITE:
|
|
AdPrint((" Dispos: FILE_OVERWRITE\n"));
|
|
break;
|
|
case FILE_OVERWRITE_IF:
|
|
AdPrint((" Dispos: FILE_OVERWRITE_IF\n"));
|
|
break;
|
|
default:
|
|
AdPrint((" Dispos: *** Unknown ***\n"));
|
|
break;
|
|
}
|
|
//#endif // UDF_LOG_CREATE_DISPOSITION
|
|
|
|
FileAttributes = (USHORT)(IrpSp->Parameters.Create.FileAttributes & FILE_ATTRIBUTE_VALID_FLAGS);
|
|
ShareAccess = IrpSp->Parameters.Create.ShareAccess;
|
|
|
|
// If the FSD does not support EA manipulation, we might return
|
|
// invalid parameter if the following are supplied.
|
|
// EA arguments are only used if a new file is created or a file is
|
|
// superseded
|
|
|
|
// But some applications _require_ EA support
|
|
// (Notepad... rather strange, isn't it ?)
|
|
|
|
// So, for such stupid ones
|
|
// !!! We shall ignore these parameters !!!
|
|
|
|
// PtrExtAttrBuffer = (struct _FILE_FULL_EA_INFORMATION *) Irp->AssociatedIrp.SystemBuffer;
|
|
// ExtAttrLength = IrpSp->Parameters.Create.EaLength;
|
|
|
|
// Get the options supplied by the user
|
|
|
|
#define OpenForBackup (RequestedOptions & FILE_OPEN_FOR_BACKUP_INTENT)
|
|
// User specifies that returned object MUST be a directory.
|
|
// Lack of presence of this flag does not mean it *cannot* be a
|
|
// directory *unless* FileOnlyRequested is set (see below)
|
|
|
|
// Presence of the flag however, does require that the returned object be
|
|
// a directory (container) object.
|
|
#define DirectoryOnlyRequested (RequestedOptions & FILE_DIRECTORY_FILE)
|
|
|
|
// User specifies that returned object MUST NOT be a directory.
|
|
// Lack of presence of this flag does not mean it *cannot* be a
|
|
// file *unless* DirectoryOnlyRequested is set (see above).
|
|
|
|
// Presence of the flag however does require that the returned object be
|
|
// a simple file (non-container) object.
|
|
#define FileOnlyRequested (RequestedOptions & FILE_NON_DIRECTORY_FILE)
|
|
|
|
// We cannot cache the file if the following flag is set.
|
|
// However, things do get a little bit interesting if caching
|
|
// has been already initiated due to a previous open ...
|
|
// (maintaining consistency then becomes a little bit more
|
|
// of a headache - see read/write file descriptions)
|
|
#define NoBufferingSpecified (RequestedOptions & FILE_NO_INTERMEDIATE_BUFFERING)
|
|
|
|
// Write-through simply means that the FSD must *not* return from
|
|
// a user write request until the data has been flushed to secondary
|
|
// storage (either to disks directly connected to the node or across
|
|
// the network in the case of a redirector)
|
|
WriteThroughRequested = (RequestedOptions & FILE_WRITE_THROUGH) ? TRUE : FALSE;
|
|
|
|
#define SequentialIoRequested (RequestedOptions & FILE_SEQUENTIAL_ONLY ? TRUE : FALSE)
|
|
|
|
// Not all of the native file system implementations support
|
|
// the delete-on-close option. All this means is that after the
|
|
// last close on the FCB has been performed, the FSD should
|
|
// delete the file. It simply saves the caller from issuing a
|
|
// separate delete request. Also, some FSD implementations might choose
|
|
// to implement a Windows NT idiosyncratic behavior wherein we
|
|
// could create such "delete-on-close" marked files under directories
|
|
// marked for deletion. Ordinarily, a FSD will not allow us to create
|
|
// a new file under a directory that has been marked for deletion.
|
|
DeleteOnCloseSpecified = (IrpSp->Parameters.Create.Options & FILE_DELETE_ON_CLOSE) ? TRUE : FALSE;
|
|
|
|
if(DeleteOnCloseSpecified) {
|
|
AdPrint((" DeleteOnClose\n"));
|
|
}
|
|
|
|
#define NoExtAttrKnowledge /*(RequestedOptions & FILE_NO_EA_KNOWLEDGE) ?*/ TRUE /*: FALSE*/
|
|
|
|
// The following flag is only used by the LAN Manager redirector
|
|
// to initiate a "new mapping" to a remote share. Typically,
|
|
// a FSD will not see this flag (especially disk based FSD's)
|
|
// CreateTreeConnection = (RequestedOptions & FILE_CREATE_TREE_CONNECTION) ? TRUE : FALSE;
|
|
|
|
// The NTFS file system for exmaple supports the OpenByFileId option.
|
|
// The FSD may also be able to associate a unique numerical ID with
|
|
// an on-disk object. The caller would get this ID in a "query file
|
|
// information" call.
|
|
|
|
// Later, the caller might decide to reopen the object, this time
|
|
// though it may supply the FSD with the file identifier instead of
|
|
// a file/path name.
|
|
#define OpenByFileId (RequestedOptions & FILE_OPEN_BY_FILE_ID)
|
|
|
|
// Are we dealing with a page file?
|
|
PageFileManipulation = (IrpSp->Flags & SL_OPEN_PAGING_FILE) ? TRUE : FALSE;
|
|
|
|
// The open target directory flag is used as part of the sequence of
|
|
// operations performed by the I/O Manager is response to a file/dir
|
|
// rename operation. See the explanation in the book for details.
|
|
OpenTargetDirectory = (IrpSp->Flags & SL_OPEN_TARGET_DIRECTORY) ? TRUE : FALSE;
|
|
|
|
// If the FSD supports case-sensitive file name checks, we may
|
|
// choose to honor the following flag ...
|
|
IgnoreCase = (IrpSp->Flags & SL_CASE_SENSITIVE) ? FALSE : TRUE;
|
|
|
|
// Ensure that the operation has been directed to a valid VCB ...
|
|
Vcb = (PVCB)(PtrIrpContext->TargetDeviceObject->DeviceExtension);
|
|
ASSERT(Vcb);
|
|
ASSERT(Vcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB);
|
|
// Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
|
|
|
|
WriteThroughRequested = WriteThroughRequested ||
|
|
(Vcb->CompatFlags & UDF_VCB_IC_FORCE_WRITE_THROUGH);
|
|
|
|
// Do some preliminary checks to make sure the operation is supported.
|
|
// We fail in the following cases immediately.
|
|
// - Open a paging file.
|
|
// - Open a file with Eas.
|
|
if(PageFileManipulation) {
|
|
ReturnedInformation = 0;
|
|
AdPrint(("Can't create a page file\n"));
|
|
try_return(RC = STATUS_ACCESS_DENIED);
|
|
}
|
|
if(ExtAttrLength) {
|
|
ReturnedInformation = 0;
|
|
AdPrint(("Can't create file with EAs\n"));
|
|
try_return(RC = STATUS_EAS_NOT_SUPPORTED);
|
|
}
|
|
|
|
UDFFlushTryBreak(Vcb);
|
|
|
|
if (Vcb->SoftEjectReq) {
|
|
AdPrint((" Eject requested\n"));
|
|
ReturnedInformation = FILE_DOES_NOT_EXIST;
|
|
try_return(RC = STATUS_FILE_INVALID);
|
|
}
|
|
|
|
// If the volume has been locked, fail the request
|
|
if ((Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_LOCKED) &&
|
|
(Vcb->VolumeLockPID != GetCurrentPID())) {
|
|
AdPrint((" Volume is locked\n"));
|
|
RC = STATUS_ACCESS_DENIED;
|
|
try_return(RC);
|
|
}
|
|
// We need EXCLUSIVE access to Vcb to avoid parallel calls to UDFVerifyVcb()
|
|
UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
|
|
AcquiredVcb = TRUE;
|
|
|
|
// Disk based file systems might decide to verify the logical volume
|
|
// (if required and only if removable media are supported) at this time
|
|
RC = UDFVerifyVcb(PtrIrpContext,Vcb);
|
|
if(!NT_SUCCESS(RC))
|
|
try_return(RC);
|
|
|
|
UDFConvertExclusiveToSharedLite(&(Vcb->VCBResource));
|
|
|
|
ASSERT(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED);
|
|
|
|
// We fail in the following cases for Read-Only volumes
|
|
// - Open a target directory.
|
|
// - Create a file.
|
|
if(
|
|
(
|
|
((Vcb->origIntegrityType == INTEGRITY_TYPE_OPEN) &&
|
|
(Vcb->CompatFlags & UDF_VCB_IC_DIRTY_RO))
|
|
#ifndef UDF_READ_ONLY_BUILD
|
|
|| (Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY)
|
|
#endif //UDF_READ_ONLY_BUILD
|
|
) &&
|
|
(DeleteOnCloseSpecified ||
|
|
OpenTargetDirectory ||
|
|
(RequestedDisposition == FILE_CREATE) ||
|
|
(RequestedDisposition == FILE_OVERWRITE) ||
|
|
(RequestedDisposition == FILE_OVERWRITE_IF) ||
|
|
(RequestedDisposition == FILE_SUPERSEDE) ||
|
|
AllocationSize) ) {
|
|
ReturnedInformation = 0;
|
|
AdPrint((" Write protected or dirty\n"));
|
|
try_return(RC = STATUS_MEDIA_WRITE_PROTECTED);
|
|
}
|
|
|
|
/* if(DesiredAccess & (FILE_READ_EA | FILE_WRITE_EA)) {
|
|
ReturnedInformation = 0;
|
|
AdPrint((" EAs not supported\n"));
|
|
try_return(RC = STATUS_ACCESS_DENIED);
|
|
}*/
|
|
|
|
// ****************
|
|
// If a Volume open is requested, satisfy it now
|
|
// ****************
|
|
if (!(PtrNewFileObject->FileName.Length) && (!PtrRelatedFileObject ||
|
|
(PtrRelatedFCB->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB))) {
|
|
|
|
BOOLEAN UndoLock = FALSE;
|
|
|
|
AdPrint((" Opening Volume\n"));
|
|
// If the supplied file name is NULL *and* either there exists
|
|
// no related file object *or* if a related file object was supplied
|
|
// but it too refers to a previously opened instance of a logical
|
|
// volume, this open must be for a logical volume.
|
|
|
|
// Note: the FSD might decide to do "special" things (whatever they
|
|
// might be) in response to an open request for the logical volume.
|
|
|
|
// Logical volume open requests are done primarily to get/set volume
|
|
// information, lock the volume, dismount the volume (using the IOCTL
|
|
// FSCTL_DISMOUNT_VOLUME) etc.
|
|
|
|
// If a volume open is requested, perform checks to ensure that
|
|
// invalid options have not also been specified ...
|
|
if ((OpenTargetDirectory) || (PtrExtAttrBuffer)) {
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
}
|
|
|
|
if (DirectoryOnlyRequested) {
|
|
// a volume is not a directory
|
|
try_return(RC = STATUS_NOT_A_DIRECTORY);
|
|
}
|
|
|
|
#ifndef UDF_READ_ONLY_BUILD
|
|
if (DeleteOnCloseSpecified) {
|
|
// delete volume.... hmm
|
|
try_return(RC = STATUS_CANNOT_DELETE);
|
|
}
|
|
|
|
if ((RequestedDisposition != FILE_OPEN) && (RequestedDisposition != FILE_OPEN_IF)) {
|
|
// cannot create a new volume, I'm afraid ...
|
|
ReturnedInformation = FILE_DOES_NOT_EXIST;
|
|
try_return(RC = STATUS_ACCESS_DENIED);
|
|
}
|
|
#endif //UDF_READ_ONLY_BUILD
|
|
|
|
UDFPrint((" ShareAccess %x, DesiredAccess %x\n", ShareAccess, DesiredAccess));
|
|
/*
|
|
if(!(ShareAccess & (FILE_SHARE_WRITE | FILE_SHARE_DELETE)) &&
|
|
!(DesiredAccess & (FILE_GENERIC_WRITE & ~SYNCHRONIZE)) &&
|
|
(ShareAccess & FILE_SHARE_READ) ) {
|
|
*/
|
|
if(!(DesiredAccess & ((GENERIC_WRITE | FILE_GENERIC_WRITE) & ~(SYNCHRONIZE | READ_CONTROL))) &&
|
|
(ShareAccess & FILE_SHARE_READ) ) {
|
|
UDFPrint((" R/O volume open\n"));
|
|
} else {
|
|
|
|
UDFPrint((" R/W volume open\n"));
|
|
if(Vcb->VCBFlags & UDF_VCB_FLAGS_MEDIA_READ_ONLY) {
|
|
UDFPrint((" media-ro\n"));
|
|
try_return(RC = STATUS_MEDIA_WRITE_PROTECTED);
|
|
}
|
|
}
|
|
|
|
if(!(ShareAccess & (FILE_SHARE_WRITE | FILE_SHARE_DELETE)) &&
|
|
!(DesiredAccess & ((GENERIC_WRITE | FILE_GENERIC_WRITE) & ~(SYNCHRONIZE | READ_CONTROL))) &&
|
|
(ShareAccess & FILE_SHARE_READ) ) {
|
|
// do nothing
|
|
} else {
|
|
|
|
if(!(ShareAccess & FILE_SHARE_READ) ||
|
|
(DesiredAccess & ((GENERIC_WRITE | FILE_GENERIC_WRITE) & ~(SYNCHRONIZE | READ_CONTROL))) ) {
|
|
// As soon as OpenVolume flushes the volume
|
|
// we should complete all pending requests (Close)
|
|
|
|
UDFPrint((" set UDF_IRP_CONTEXT_FLUSH2_REQUIRED\n"));
|
|
PtrIrpContext->IrpContextFlags |= UDF_IRP_CONTEXT_FLUSH2_REQUIRED;
|
|
|
|
/*
|
|
UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCount));
|
|
UDFReleaseResource(&(Vcb->VCBResource));
|
|
AcquiredVcb = FALSE;
|
|
|
|
if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK)) {
|
|
UDFCloseAllSystemDelayedInDir(Vcb, Vcb->RootDirFCB->FileInfo);
|
|
}
|
|
#ifdef UDF_DELAYED_CLOSE
|
|
UDFCloseAllDelayed(Vcb);
|
|
#endif //UDF_DELAYED_CLOSE
|
|
|
|
UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
|
|
AcquiredVcb = TRUE;
|
|
UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
|
|
*/
|
|
}
|
|
}
|
|
|
|
// If the user does not want to share write or delete then we will try
|
|
// and take out a lock on the volume.
|
|
if(!(ShareAccess & (FILE_SHARE_WRITE | FILE_SHARE_DELETE))) {
|
|
// Do a quick check here for handles on exclusive open.
|
|
if ((Vcb->VCBHandleCount) &&
|
|
!(ShareAccess & FILE_SHARE_READ)) {
|
|
// Sharing violation
|
|
UDFPrint((" !FILE_SHARE_READ + open handles (%d)\n", Vcb->VCBHandleCount));
|
|
try_return(RC = STATUS_SHARING_VIOLATION);
|
|
}
|
|
if(PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_FLUSH2_REQUIRED) {
|
|
|
|
UDFPrint((" perform flush\n"));
|
|
PtrIrpContext->IrpContextFlags &= ~UDF_IRP_CONTEXT_FLUSH2_REQUIRED;
|
|
|
|
UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCount));
|
|
UDFReleaseResource(&(Vcb->VCBResource));
|
|
AcquiredVcb = FALSE;
|
|
|
|
if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK)) {
|
|
UDFCloseAllSystemDelayedInDir(Vcb, Vcb->RootDirFCB->FileInfo);
|
|
}
|
|
#ifdef UDF_DELAYED_CLOSE
|
|
UDFCloseAllDelayed(Vcb);
|
|
#endif //UDF_DELAYED_CLOSE
|
|
|
|
UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
|
|
AcquiredVcb = TRUE;
|
|
UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
|
|
|
|
UDFFlushLogicalVolume(NULL, NULL, Vcb);
|
|
|
|
if((ShareAccess & FILE_SHARE_READ) &&
|
|
((Vcb->VCBOpenCount - UDF_RESIDUAL_REFERENCE) != (Vcb->VCBOpenCountRO))) {
|
|
UDFPrint((" FILE_SHARE_READ + R/W handles: %d(%d) -> STATUS_SHARING_VIOLATION ?\n",
|
|
Vcb->VCBOpenCount - UDF_RESIDUAL_REFERENCE,
|
|
Vcb->VCBOpenCountRO));
|
|
/* we shall not check it here, let System do it in IoCheckShareAccess() */
|
|
//try_return(RC = STATUS_SHARING_VIOLATION);
|
|
}
|
|
}
|
|
// Lock the volume
|
|
if(!(ShareAccess & FILE_SHARE_READ)) {
|
|
UDFPrint((" set Lock\n"));
|
|
Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_LOCKED;
|
|
Vcb->VolumeLockFileObject = PtrNewFileObject;
|
|
UndoLock = TRUE;
|
|
} else
|
|
if(DesiredAccess & ((GENERIC_WRITE | FILE_GENERIC_WRITE) & ~(SYNCHRONIZE | READ_CONTROL))) {
|
|
UDFPrint((" set UDF_IRP_CONTEXT_FLUSH_REQUIRED\n"));
|
|
PtrIrpContext->IrpContextFlags |= UDF_IRP_CONTEXT_FLUSH_REQUIRED;
|
|
}
|
|
}
|
|
|
|
PtrNewFcb = (PtrUDFFCB)Vcb;
|
|
ASSERT(!(PtrNewFcb->FCBFlags & UDF_FCB_DELETE_ON_CLOSE));
|
|
|
|
RC = UDFOpenFile(Vcb, PtrNewFileObject, PtrNewFcb);
|
|
if (!NT_SUCCESS(RC))
|
|
goto op_vol_accs_dnd;
|
|
|
|
PtrNewCcb = (PtrUDFCCB)(PtrNewFileObject->FsContext2);
|
|
if(PtrNewCcb) PtrNewCcb->CCBFlags |= UDF_CCB_VOLUME_OPEN;
|
|
// Check _Security_
|
|
RC = UDFCheckAccessRights(NULL, AccessState, Vcb->RootDirFCB, PtrNewCcb, DesiredAccess, ShareAccess);
|
|
if (!NT_SUCCESS(RC)) {
|
|
AdPrint((" Access violation (Volume)\n"));
|
|
goto op_vol_accs_dnd;
|
|
}
|
|
// Check _ShareAccess_
|
|
RC = UDFCheckAccessRights(PtrNewFileObject, AccessState, PtrNewFcb, PtrNewCcb, DesiredAccess, ShareAccess);
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Sharing violation (Volume)\n"));
|
|
op_vol_accs_dnd:
|
|
if(UndoLock) {
|
|
Vcb->VCBFlags &= ~UDF_VCB_FLAGS_VOLUME_LOCKED;
|
|
Vcb->VolumeLockFileObject = NULL;
|
|
}
|
|
try_return(RC);
|
|
}
|
|
|
|
// NoBufferingSpecified = TRUE; See #define above
|
|
RequestedOptions |= FILE_NO_INTERMEDIATE_BUFFERING;
|
|
|
|
ReturnedInformation = FILE_OPENED;
|
|
UDFNotifyVolumeEvent(PtrNewFileObject, FSRTL_VOLUME_LOCK);
|
|
try_return(RC);
|
|
}
|
|
|
|
if((Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK) &&
|
|
(!(Vcb->CompatFlags & UDF_VCB_IC_SHOW_BLANK_CD) || UDFGlobalData.AutoFormatCount)) {
|
|
ReturnedInformation = 0;
|
|
AdPrint((" Can't open anything on blank volume ;)\n"));
|
|
try_return(RC = STATUS_OBJECT_NAME_NOT_FOUND);
|
|
}
|
|
|
|
if(UdfIllegalFcbAccess(Vcb,DesiredAccess)) {
|
|
ReturnedInformation = 0;
|
|
AdPrint((" Illegal share access\n"));
|
|
try_return(RC = STATUS_ACCESS_DENIED);
|
|
}
|
|
// we could mount blank R/RW media in order to allow
|
|
// user-mode applications to get access with Write privileges
|
|
ASSERT(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED);
|
|
|
|
// we should check appropriate privilege if OpenForBackup requested
|
|
if(OpenForBackup) {
|
|
if (!SeSinglePrivilegeCheck(SeExports->SeBackupPrivilege, UserMode)) {
|
|
try_return(RC = STATUS_PRIVILEGE_NOT_HELD);
|
|
}
|
|
}
|
|
|
|
// The FSD might wish to implement the open-by-id option. The "id"
|
|
// is some unique numerical representation of the on-disk object.
|
|
// The caller then therefore give us this file id and the FSD
|
|
// should be completely capable of "opening" the object (it must
|
|
// exist since the caller received an id for the object from the
|
|
// FSD in a "query file" call ...
|
|
|
|
// If the file has been deleted in the meantime, we'll return
|
|
// "not found"
|
|
|
|
// ****************
|
|
// Open by FileID
|
|
// ****************
|
|
if (OpenByFileId) {
|
|
// perform the open ...
|
|
PUNICODE_STRING TmpPath;
|
|
LONGLONG Id;
|
|
|
|
UDFPrint((" open by File ID\n"));
|
|
if(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK) {
|
|
ReturnedInformation = 0;
|
|
AdPrint((" Can't open by FileID on blank volume ;)\n"));
|
|
try_return(RC = STATUS_OBJECT_NAME_NOT_FOUND);
|
|
}
|
|
|
|
if (TargetObjectName.Length != sizeof(FILE_ID)) {
|
|
AdPrint((" Invalid file ID\n"));
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
}
|
|
Id = *((FILE_ID*)(TargetObjectName.Buffer));
|
|
AdPrint((" Opening by ID %8.8x%8.8x\n", (ULONG)(Id>>32), (ULONG)Id));
|
|
if ((RequestedDisposition != FILE_OPEN) &&
|
|
(RequestedDisposition != FILE_OPEN_IF)) {
|
|
AdPrint((" Illegal disposition for ID open\n"));
|
|
try_return(RC = STATUS_ACCESS_DENIED);
|
|
}
|
|
|
|
RC = UDFGetOpenParamsByFileId(Vcb, Id, &TmpPath, &IgnoreCase);
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" ID open failed\n"));
|
|
try_return(RC);
|
|
}
|
|
// simulate absolute path open
|
|
/* if(!NT_SUCCESS(RC = MyInitUnicodeString(&TargetObjectName, L"")) ||
|
|
!NT_SUCCESS(RC = MyAppendUnicodeStringToStringTag(&TargetObjectName, TmpPath, MEM_USABS_TAG))) {*/
|
|
if(!NT_SUCCESS(RC = MyCloneUnicodeString(&TargetObjectName, TmpPath))) {
|
|
AdPrint((" Init String failed\n"));
|
|
try_return(RC);
|
|
}
|
|
//ASSERT(TargetObjectName.Buffer);
|
|
AbsolutePathName = TargetObjectName;
|
|
PtrRelatedFileObject = NULL;
|
|
} else
|
|
// ****************
|
|
// Relative open
|
|
// ****************
|
|
// Now determine the starting point from which to begin the parsing
|
|
if (PtrRelatedFileObject) {
|
|
// We have a user supplied related file object.
|
|
// This implies a "relative" open i.e. relative to the directory
|
|
// represented by the related file object ...
|
|
|
|
UDFPrint((" PtrRelatedFileObject %x, FCB %x\n", PtrRelatedFileObject, PtrRelatedFCB));
|
|
// Note: The only purpose FSD implementations ever have for
|
|
// the related file object is to determine whether this
|
|
// is a relative open or not. At all other times (including
|
|
// during I/O operations), this field is meaningless from
|
|
// the FSD's perspective.
|
|
if (!(PtrRelatedFCB->FCBFlags & UDF_FCB_DIRECTORY)) {
|
|
// we must have a directory as the "related" object
|
|
RC = STATUS_INVALID_PARAMETER;
|
|
AdPrint((" Related object must be a directory\n"));
|
|
AdPrint((" Flags %x\n", PtrRelatedFCB->FCBFlags));
|
|
_SEH2_TRY {
|
|
AdPrint((" ObjName %x, ", PtrRelatedFCB->FCBName->ObjectName));
|
|
AdPrint((" Name %S\n", PtrRelatedFCB->FCBName->ObjectName.Buffer));
|
|
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
|
|
AdPrint((" exception when printing name\n"));
|
|
} _SEH2_END;
|
|
try_return(RC);
|
|
}
|
|
|
|
// So we have a directory, ensure that the name begins with
|
|
// a "\" i.e. begins at the root and does *not* begin with a "\\"
|
|
// NOTE: This is just an example of the kind of path-name string
|
|
// validation that a FSD must do. Although the remainder of
|
|
// the code may not include such checks, any commercial
|
|
// FSD *must* include such checking (no one else, including
|
|
// the I/O Manager will perform checks on the FSD's behalf)
|
|
if (!(RelatedObjectName.Length) || (RelatedObjectName.Buffer[0] != L'\\')) {
|
|
AdPrint((" Wrong pathname (1)\n"));
|
|
RC = STATUS_INVALID_PARAMETER;
|
|
try_return(RC);
|
|
}
|
|
// similarly, if the target file name starts with a "\", it
|
|
// is wrong since the target file name can no longer be absolute
|
|
ASSERT(TargetObjectName.Buffer || !TargetObjectName.Length);
|
|
if (TargetObjectName.Length && (TargetObjectName.Buffer[0] == L'\\')) {
|
|
AdPrint((" Wrong pathname (2)\n"));
|
|
RC = STATUS_INVALID_PARAMETER;
|
|
try_return(RC);
|
|
}
|
|
// Create an absolute path-name. We could potentially use
|
|
// the absolute path-name if we cache previously opened
|
|
// file/directory object names.
|
|
/* if(!NT_SUCCESS(RC = MyInitUnicodeString(&AbsolutePathName, L"")) ||
|
|
!NT_SUCCESS(RC MyAppendUnicodeStringToStringTag(&AbsolutePathName, &RelatedObjectName, MEM_USABS_TAG)))*/
|
|
if(!NT_SUCCESS(RC = MyCloneUnicodeString(&AbsolutePathName, &RelatedObjectName)))
|
|
try_return(RC);
|
|
if(RelatedObjectName.Length &&
|
|
(RelatedObjectName.Buffer[ (RelatedObjectName.Length/sizeof(WCHAR)) - 1 ] != L'\\')) {
|
|
RC = MyAppendUnicodeToString(&AbsolutePathName, L"\\");
|
|
if(!NT_SUCCESS(RC)) try_return(RC);
|
|
}
|
|
if(!AbsolutePathName.Length ||
|
|
(AbsolutePathName.Buffer[ (AbsolutePathName.Length/sizeof(WCHAR)) - 1 ] != L'\\')) {
|
|
ASSERT(TargetObjectName.Buffer);
|
|
if(TargetObjectName.Length && TargetObjectName.Buffer[0] != L'\\') {
|
|
RC = MyAppendUnicodeToString(&AbsolutePathName, L"\\");
|
|
if(!NT_SUCCESS(RC)) try_return(RC);
|
|
}
|
|
}
|
|
//ASSERT(TargetObjectName.Buffer);
|
|
RC = MyAppendUnicodeStringToStringTag(&AbsolutePathName, &TargetObjectName, MEM_USABS_TAG);
|
|
if(!NT_SUCCESS(RC))
|
|
try_return(RC);
|
|
|
|
} else {
|
|
// ****************
|
|
// Absolute open
|
|
// ****************
|
|
// The suplied path-name must be an absolute path-name i.e.
|
|
// starting at the root of the file system tree
|
|
UDFPrint((" Absolute open\n"));
|
|
ASSERT(TargetObjectName.Buffer);
|
|
if (!TargetObjectName.Length || TargetObjectName.Buffer[0] != L'\\') {
|
|
AdPrint((" Wrong target name (1)\n"));
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
}
|
|
/* if(!NT_SUCCESS(RC = MyInitUnicodeString(&AbsolutePathName, L"")) ||
|
|
!NT_SUCCESS(RC = MyAppendUnicodeStringToStringTag(&AbsolutePathName, &TargetObjectName, MEM_USABS_TAG)))*/
|
|
ASSERT(TargetObjectName.Buffer);
|
|
if(!NT_SUCCESS(RC = MyCloneUnicodeString(&AbsolutePathName, &TargetObjectName)))
|
|
try_return(RC);
|
|
}
|
|
// Win 32 protection :)
|
|
if ((AbsolutePathName.Length >= sizeof(WCHAR)*2) &&
|
|
(AbsolutePathName.Buffer[1] == L'\\') &&
|
|
(AbsolutePathName.Buffer[0] == L'\\')) {
|
|
|
|
// If there are still two beginning backslashes, the name is bogus.
|
|
if ((AbsolutePathName.Length > 2*sizeof(WCHAR)) &&
|
|
(AbsolutePathName.Buffer[2] == L'\\')) {
|
|
AdPrint((" Wrong target name (2)\n"));
|
|
try_return (RC = STATUS_OBJECT_NAME_INVALID);
|
|
}
|
|
// Slide the name down in the buffer.
|
|
RtlMoveMemory( AbsolutePathName.Buffer,
|
|
AbsolutePathName.Buffer + 1,
|
|
AbsolutePathName.Length ); // .Length includes
|
|
// NULL-terminator
|
|
AbsolutePathName.Length -= sizeof(WCHAR);
|
|
}
|
|
if ( (AbsolutePathName.Length > sizeof(WCHAR) ) &&
|
|
(AbsolutePathName.Buffer[ (AbsolutePathName.Length/sizeof(WCHAR)) - 1 ] == L'\\') ) {
|
|
|
|
AbsolutePathName.Length -= sizeof(WCHAR);
|
|
}
|
|
// TERMINATOR (2) ;)
|
|
AbsolutePathName.Buffer[AbsolutePathName.Length/sizeof(WCHAR)] = 0;
|
|
|
|
// Sometimes W2000 decides to duplicate handle of
|
|
// already opened File/Dir. In this case it sends us
|
|
// RelatedFileObject & specifies zero-filled RelativePath
|
|
if(!TargetObjectName.Length) {
|
|
TargetObjectName = AbsolutePathName;
|
|
OpenExisting = TRUE;
|
|
}
|
|
//ASSERT(TargetObjectName.Buffer);
|
|
|
|
// ****************
|
|
// First, check if the caller simply wishes to open the Root
|
|
// of the file system tree.
|
|
// ****************
|
|
if (AbsolutePathName.Length == sizeof(WCHAR)) {
|
|
AdPrint((" Opening RootDir\n"));
|
|
// this is an open of the root directory, ensure that the caller
|
|
// has not requested a file only
|
|
if (FileOnlyRequested || (RequestedDisposition == FILE_SUPERSEDE) ||
|
|
(RequestedDisposition == FILE_OVERWRITE) ||
|
|
(RequestedDisposition == FILE_OVERWRITE_IF)) {
|
|
AdPrint((" Can't overwrite RootDir\n"));
|
|
RC = STATUS_FILE_IS_A_DIRECTORY;
|
|
try_return(RC);
|
|
}
|
|
|
|
#if 0
|
|
CollectStatistics(Vcb, MetaDataReads);
|
|
#endif
|
|
|
|
if (DeleteOnCloseSpecified) {
|
|
// delete RootDir.... rather strange idea... I dislike it
|
|
AdPrint((" Can't delete RootDir\n"));
|
|
try_return(RC = STATUS_CANNOT_DELETE);
|
|
}
|
|
|
|
PtrNewFcb = Vcb->RootDirFCB;
|
|
RC = UDFOpenFile(Vcb, PtrNewFileObject, PtrNewFcb);
|
|
if(!NT_SUCCESS(RC)) try_return(RC);
|
|
// DbgPrint("UDF: Open/Create RootDir : ReferenceCount %x\n",PtrNewFcb->ReferenceCount);
|
|
UDFReferenceFile__(PtrNewFcb->FileInfo);
|
|
PtrNewCcb = (PtrUDFCCB)(PtrNewFileObject->FsContext2);
|
|
TreeLength = 1;
|
|
|
|
RC = UDFCheckAccessRights(PtrNewFileObject, AccessState, PtrNewFcb, PtrNewCcb, DesiredAccess, ShareAccess);
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Access/Sharing violation (RootDir)\n"));
|
|
try_return(RC);
|
|
}
|
|
|
|
ReturnedInformation = FILE_OPENED;
|
|
|
|
try_return(RC);
|
|
} // end of OpenRootDir
|
|
|
|
_SEH2_TRY {
|
|
AdPrint((" Opening file %ws %8.8x\n",AbsolutePathName.Buffer, PtrNewFileObject));
|
|
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
|
|
AdPrint((" Exception when printing FN\n"));
|
|
} _SEH2_END;
|
|
// ****************
|
|
// Check if we have DuplicateHandle (or Reopen) request
|
|
// ****************
|
|
if(OpenExisting) {
|
|
|
|
// BrutePoint();
|
|
// We don't handle OpenTargetDirectory in this case
|
|
if(OpenTargetDirectory)
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
|
|
// Init environment to simulate normal open procedure behavior
|
|
/* if(!NT_SUCCESS(RC = MyInitUnicodeString(&LocalPath, L"")) ||
|
|
!NT_SUCCESS(RC = MyAppendUnicodeStringToStringTag(&LocalPath, &TargetObjectName, MEM_USLOC_TAG)))*/
|
|
ASSERT(TargetObjectName.Buffer);
|
|
if(!NT_SUCCESS(RC = MyCloneUnicodeString(&LocalPath, &TargetObjectName)))
|
|
try_return(RC);
|
|
|
|
ASSERT(PtrRelatedFCB);
|
|
RelatedFileInfo = PtrRelatedFCB->FileInfo;
|
|
|
|
RC = STATUS_SUCCESS;
|
|
NewFileInfo =
|
|
LastGoodFileInfo = RelatedFileInfo;
|
|
|
|
RelatedFileInfo =
|
|
OldRelatedFileInfo = RelatedFileInfo->ParentFile;
|
|
PtrRelatedFCB = PtrRelatedFCB->ParentFcb;
|
|
// prevent releasing parent structures
|
|
UDFAcquireParent(RelatedFileInfo, &Res1, &Res2);
|
|
TreeLength++;
|
|
|
|
if(Res1) UDFReleaseResource(Res1);
|
|
if(Res2) UDFReleaseResource(Res2);
|
|
|
|
UDF_CHECK_PAGING_IO_RESOURCE(RelatedFileInfo->Fcb->NTRequiredFCB);
|
|
UDFAcquireResourceExclusive(Res2 = &(RelatedFileInfo->Fcb->NTRequiredFCB->MainResource),TRUE);
|
|
PtrNewFcb = NewFileInfo->Fcb;
|
|
|
|
UDF_CHECK_PAGING_IO_RESOURCE(PtrNewFcb->NTRequiredFCB);
|
|
UDFAcquireResourceExclusive(Res1 = &(PtrNewFcb->NTRequiredFCB->MainResource),TRUE);
|
|
UDFReferenceFile__(NewFileInfo);
|
|
TreeLength++;
|
|
|
|
goto AlreadyOpened;
|
|
}
|
|
|
|
if(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK) {
|
|
ReturnedInformation = 0;
|
|
AdPrint((" Can't open File on blank volume ;)\n"));
|
|
ReturnedInformation = FILE_DOES_NOT_EXIST;
|
|
try_return(RC = STATUS_OBJECT_NAME_NOT_FOUND);
|
|
}
|
|
|
|
//AdPrint((" Opening file %ws %8.8x\n",AbsolutePathName.Buffer, PtrNewFileObject));
|
|
|
|
if(AbsolutePathName.Length > UDF_X_PATH_LEN*sizeof(WCHAR)) {
|
|
try_return(RC = STATUS_OBJECT_NAME_INVALID);
|
|
}
|
|
|
|
// validate path specified
|
|
// (sometimes we can see here very strange characters ;)
|
|
if(!UDFIsNameValid(&AbsolutePathName, &StreamOpen, &SNameIndex)) {
|
|
AdPrint((" Absolute path is not valid\n"));
|
|
try_return(RC = STATUS_OBJECT_NAME_INVALID);
|
|
}
|
|
if(StreamOpen && !UDFStreamsSupported(Vcb)) {
|
|
ReturnedInformation = FILE_DOES_NOT_EXIST;
|
|
try_return(RC = STATUS_OBJECT_NAME_INVALID);
|
|
}
|
|
|
|
RC = MyInitUnicodeString(&LocalPath, L"");
|
|
if(!NT_SUCCESS(RC))
|
|
try_return(RC);
|
|
if (PtrRelatedFileObject) {
|
|
// Our "start directory" is the one identified
|
|
// by the related file object
|
|
RelatedFileInfo = PtrRelatedFCB->FileInfo;
|
|
if(RelatedFileInfo != Vcb->RootDirFCB->FileInfo) {
|
|
RC = MyAppendUnicodeStringToStringTag(&LocalPath, &(PtrRelatedFCB->FCBName->ObjectName), MEM_USLOC_TAG);
|
|
if(!NT_SUCCESS(RC))
|
|
try_return(RC);
|
|
}
|
|
if(TargetObjectName.Buffer != AbsolutePathName.Buffer) {
|
|
ASSERT(TargetObjectName.Buffer);
|
|
if(!NT_SUCCESS(RC = MyCloneUnicodeString(&TailName, &TargetObjectName))) {
|
|
AdPrint((" Init String 'TargetObjectName' failed\n"));
|
|
try_return(RC);
|
|
}
|
|
TailNameBuffer = TailName.Buffer;
|
|
} else {
|
|
TailName = AbsolutePathName;
|
|
}
|
|
} else {
|
|
// Start at the root of the file system
|
|
RelatedFileInfo = Vcb->RootDirFCB->FileInfo;
|
|
TailName = AbsolutePathName;
|
|
}
|
|
|
|
if(StreamOpen) {
|
|
StreamName = AbsolutePathName;
|
|
StreamName.Buffer += SNameIndex;
|
|
StreamName.Length -= (USHORT)SNameIndex*sizeof(WCHAR);
|
|
// if StreamOpen specified & stream name starts with NULL character
|
|
// we should create Stream Dir at first
|
|
TailName.Length -= (AbsolutePathName.Length - (USHORT)SNameIndex*sizeof(WCHAR));
|
|
AbsolutePathName.Length = (USHORT)SNameIndex*sizeof(WCHAR);
|
|
}
|
|
CurName.MaximumLength = TailName.MaximumLength;
|
|
|
|
RC = STATUS_SUCCESS;
|
|
LastGoodName.Length = 0;
|
|
LastGoodFileInfo = RelatedFileInfo;
|
|
// reference RelatedObject to prevent releasing parent structures
|
|
UDFAcquireParent(RelatedFileInfo, &Res1, &Res2);
|
|
TreeLength++;
|
|
|
|
// go into a loop parsing the supplied name
|
|
|
|
// Note that we may have to "open" intermediate directory objects
|
|
// while traversing the path. We should __try to reuse existing code
|
|
// whenever possible therefore we should consider using a common
|
|
// open routine regardless of whether the open is on behalf of the
|
|
// caller or an intermediate (internal) open performed by the driver.
|
|
|
|
// ****************
|
|
// now we'll parse path to desired file
|
|
// ****************
|
|
|
|
while (TRUE) {
|
|
|
|
// remember last 'good' ('good' means NO ERRORS before) path tail
|
|
if(NT_SUCCESS(RC)) {
|
|
LastGoodTail = TailName;
|
|
while(LastGoodTail.Buffer[0] == L'\\') {
|
|
LastGoodTail.Buffer++;
|
|
LastGoodTail.Length -= sizeof(WCHAR);
|
|
}
|
|
}
|
|
// get next path part...
|
|
TmpBuffer = TailName.Buffer;
|
|
TailName.Buffer = UDFDissectName(TailName.Buffer,&(CurName.Length) );
|
|
TailName.Length -= (USHORT)((ULONG_PTR)(TailName.Buffer) - (ULONG_PTR)TmpBuffer);
|
|
CurName.Buffer = TailName.Buffer - CurName.Length;
|
|
CurName.Length *= sizeof(WCHAR);
|
|
CurName.MaximumLength = CurName.Length + sizeof(WCHAR);
|
|
// check if we have already opened the component before last one
|
|
// in this case OpenTargetDir request will be served in a special
|
|
// way...
|
|
if(OpenTargetDirectory && NT_SUCCESS(RC) && !TailName.Length) {
|
|
// check if we should open SDir..
|
|
if(!StreamOpen ||
|
|
(TailName.Buffer[0]!=L':')) {
|
|
// no, we should not. Continue with OpenTargetDir
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( CurName.Length &&
|
|
(NT_SUCCESS(RC) || !StreamOpen)) {
|
|
// ...wow! non-zero! try to open!
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Error opening path component\n"));
|
|
// we haven't reached last name part... hm..
|
|
// probably, the path specified is invalid..
|
|
// or we had a hard error... What else can we do ?
|
|
// Only say ..CK OFF !!!!
|
|
if(RC == STATUS_OBJECT_NAME_NOT_FOUND)
|
|
RC = STATUS_OBJECT_PATH_NOT_FOUND;
|
|
ReturnedInformation = FILE_DOES_NOT_EXIST;
|
|
try_return(RC);
|
|
}
|
|
|
|
ASSERT_REF(RelatedFileInfo->Fcb->ReferenceCount >= RelatedFileInfo->RefCount);
|
|
|
|
if(RelatedFileInfo && (TreeLength>1)) {
|
|
// it was an internal Open operation. Thus, assume
|
|
// RelatedFileInfo's Fcb to be valid
|
|
RelatedFileInfo->Fcb->NTRequiredFCB->NtReqFCBFlags |= UDF_NTREQ_FCB_VALID;
|
|
RelatedFileInfo->Fcb->FCBFlags |= UDF_FCB_VALID;
|
|
}
|
|
// check path fragment size
|
|
if(CurName.Length > UDF_X_NAME_LEN * sizeof(WCHAR)) {
|
|
AdPrint((" Path component is too long\n"));
|
|
try_return(RC = STATUS_OBJECT_NAME_INVALID);
|
|
}
|
|
// ...and now release previously acquired objects,
|
|
if(Res1) UDFReleaseResource(Res1);
|
|
if(Res2) {
|
|
UDFReleaseResource(Res2);
|
|
Res2 = NULL;
|
|
}
|
|
// acquire new _parent_ directory & try to open what
|
|
// we want.
|
|
|
|
UDF_CHECK_PAGING_IO_RESOURCE(RelatedFileInfo->Fcb->NTRequiredFCB);
|
|
UDFAcquireResourceExclusive(Res1 = &(RelatedFileInfo->Fcb->NTRequiredFCB->MainResource),TRUE);
|
|
|
|
// check traverse rights
|
|
RC = UDFCheckAccessRights(NULL, NULL, RelatedFileInfo->Fcb, PtrRelatedCCB, FILE_TRAVERSE, 0);
|
|
if(!NT_SUCCESS(RC)) {
|
|
NewFileInfo = NULL;
|
|
AdPrint((" Traverse check failed\n"));
|
|
goto Skip_open_attempt;
|
|
}
|
|
// check if we should open normal File/Dir or SDir
|
|
if(CurName.Buffer[0] != ':') {
|
|
// standard open, nothing interesting....
|
|
RC = UDFOpenFile__(Vcb,
|
|
IgnoreCase,TRUE,&CurName,
|
|
RelatedFileInfo,&NewFileInfo,NULL);
|
|
if(RC == STATUS_FILE_DELETED) {
|
|
// file has gone, but system still remembers it...
|
|
NewFileInfo = NULL;
|
|
AdPrint((" File deleted\n"));
|
|
RC = STATUS_ACCESS_DENIED;
|
|
#ifdef UDF_DBG
|
|
} else
|
|
if(RC == STATUS_NOT_A_DIRECTORY) {
|
|
AdPrint((" Not a directory\n"));
|
|
#endif // UDF_DBG
|
|
} else
|
|
if(RC == STATUS_SHARING_PAUSED) {
|
|
AdPrint((" Dloc is being initialized\n"));
|
|
BrutePoint();
|
|
RC = STATUS_SHARING_VIOLATION;
|
|
}
|
|
} else {
|
|
// And here we should open Stream Dir (if any, of cource)
|
|
RC = UDFOpenStreamDir__(Vcb, RelatedFileInfo, &NewFileInfo);
|
|
if(NT_SUCCESS(RC)) {
|
|
SuccessOpen_SDir:
|
|
// this indicates that we needn't Stream Dir creation
|
|
StreamExists = TRUE;
|
|
StreamName.Buffer++;
|
|
StreamName.Length-=sizeof(WCHAR);
|
|
// update TailName
|
|
TailName = StreamName;
|
|
} else
|
|
if(RC == STATUS_NOT_FOUND) {
|
|
#ifndef UDF_READ_ONLY_BUILD
|
|
// Stream Dir doesn't exist, but caller wants it to be
|
|
// created. Lets try to help him...
|
|
if((RequestedDisposition == FILE_CREATE) ||
|
|
(RequestedDisposition == FILE_OPEN_IF) ||
|
|
(RequestedDisposition == FILE_OVERWRITE_IF) ||
|
|
OpenTargetDirectory ) {
|
|
RC = UDFCreateStreamDir__(Vcb, RelatedFileInfo, &NewFileInfo);
|
|
if(NT_SUCCESS(RC))
|
|
goto SuccessOpen_SDir;
|
|
}
|
|
#endif //UDF_READ_ONLY_BUILD
|
|
}
|
|
/* } else {
|
|
AdPrint((" File deleted (2)\n"));
|
|
RC = STATUS_ACCESS_DENIED;*/
|
|
}
|
|
#if 0
|
|
CollectStatistics(Vcb, MetaDataReads);
|
|
#endif
|
|
|
|
Skip_open_attempt:
|
|
|
|
// check if we have successfully opened path component
|
|
if(NT_SUCCESS(RC)) {
|
|
// Yesss !!!
|
|
if (!(PtrNewFcb = NewFileInfo->Fcb)) {
|
|
// It is a first open operation
|
|
// Allocate new FCB
|
|
// Here we set FileObject pointer to NULL to avoid
|
|
// new CCB allocation
|
|
RC = UDFFirstOpenFile(Vcb,
|
|
NULL, &PtrNewFcb, RelatedFileInfo, NewFileInfo,
|
|
&LocalPath, &CurName);
|
|
|
|
if(!NT_SUCCESS(RC)) {
|
|
BrutePoint();
|
|
AdPrint((" Can't perform FirstOpen\n"));
|
|
UDFCloseFile__(Vcb, NewFileInfo);
|
|
if(PtrNewFcb) UDFCleanUpFCB(PtrNewFcb);
|
|
PtrNewFcb = NULL;
|
|
NewFileInfo->Fcb = NULL;
|
|
if(UDFCleanUpFile__(Vcb, NewFileInfo)) {
|
|
MyFreePool__(NewFileInfo);
|
|
NewFileInfo = NULL;
|
|
}
|
|
try_return(RC);
|
|
}
|
|
} else {
|
|
// It is not a first open operation
|
|
// Validate Fcb. It is possible to get
|
|
// not completly initialized Fcb here.
|
|
if(!(PtrNewFcb->FCBFlags & UDF_FCB_VALID)) {
|
|
BrutePoint();
|
|
AdPrint((" Fcb not valid\n"));
|
|
UDFCloseFile__(Vcb, NewFileInfo);
|
|
PtrNewFcb = NULL;
|
|
if(UDFCleanUpFile__(Vcb, NewFileInfo)) {
|
|
MyFreePool__(NewFileInfo);
|
|
NewFileInfo = NULL;
|
|
}
|
|
try_return(RC = STATUS_ACCESS_DENIED);
|
|
}
|
|
}
|
|
// Acquire newly opened File...
|
|
Res2 = Res1;
|
|
UDF_CHECK_PAGING_IO_RESOURCE(NewFileInfo->Fcb->NTRequiredFCB);
|
|
UDFAcquireResourceExclusive(Res1 = &(NewFileInfo->Fcb->NTRequiredFCB->MainResource),TRUE);
|
|
// ...and reference it
|
|
UDFInterlockedIncrement((PLONG)&(PtrNewFcb->ReferenceCount));
|
|
UDFInterlockedIncrement((PLONG)&(PtrNewFcb->NTRequiredFCB->CommonRefCount));
|
|
|
|
ASSERT_REF(PtrNewFcb->ReferenceCount >= NewFileInfo->RefCount);
|
|
// update unwind information
|
|
LastGoodFileInfo = NewFileInfo;
|
|
LastGoodName = CurName;
|
|
TreeLength++;
|
|
// update current path
|
|
if(!StreamOpen ||
|
|
((CurName.Buffer[0] != L':') &&
|
|
(!LocalPath.Length || (LocalPath.Buffer[LocalPath.Length/sizeof(WCHAR)-1] != L':'))) ) {
|
|
// we should not insert '\' before or after ':'
|
|
ASSERT(!LocalPath.Length ||
|
|
(LocalPath.Buffer[LocalPath.Length/2-1] != L'\\'));
|
|
RC = MyAppendUnicodeToString(&LocalPath, L"\\");
|
|
if(!NT_SUCCESS(RC)) try_return(RC);
|
|
}
|
|
RC = MyAppendUnicodeStringToStringTag(&LocalPath, &CurName, MEM_USLOC_TAG);
|
|
if(!NT_SUCCESS(RC))
|
|
try_return(RC);
|
|
// DbgPrint("UDF: Open/Create File %ws : ReferenceCount %x\n",CurName.Buffer,PtrNewFcb->ReferenceCount);
|
|
} else {
|
|
AdPrint((" Can't open file\n"));
|
|
// We have failed durring last Open attempt
|
|
// Roll back to last good state
|
|
PtrUDFNTRequiredFCB NtReqFcb = NULL;
|
|
// Cleanup FileInfo if any
|
|
if(NewFileInfo) {
|
|
PtrNewFcb = NewFileInfo->Fcb;
|
|
// acquire appropriate resource if possible
|
|
if(PtrNewFcb &&
|
|
PtrNewFcb->NTRequiredFCB) {
|
|
NtReqFcb = PtrNewFcb->NTRequiredFCB;
|
|
Res2 = Res1;
|
|
UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
|
|
UDFAcquireResourceExclusive(Res1 = &(NtReqFcb->MainResource),TRUE);
|
|
}
|
|
// cleanup pointer to Fcb in FileInfo to allow
|
|
// UDF_INFO package release FileInfo if there are
|
|
// no more references
|
|
if(PtrNewFcb &&
|
|
!PtrNewFcb->ReferenceCount &&
|
|
!PtrNewFcb->OpenHandleCount) {
|
|
NewFileInfo->Fcb = NULL;
|
|
}
|
|
// cleanup pointer to CommonFcb in Dloc to allow
|
|
// UDF_INFO package release Dloc if there are
|
|
// no more references
|
|
if(NewFileInfo->Dloc &&
|
|
!NewFileInfo->Dloc->LinkRefCount &&
|
|
(!PtrNewFcb || !PtrNewFcb->ReferenceCount)) {
|
|
NewFileInfo->Dloc->CommonFcb = NULL;
|
|
}
|
|
// try to release FileInfo
|
|
if(UDFCleanUpFile__(Vcb, NewFileInfo)) {
|
|
ASSERT(!PtrNewFcb);
|
|
if(PtrNewFcb) {
|
|
BrutePoint();
|
|
UDFCleanUpFCB(PtrNewFcb);
|
|
}
|
|
MyFreePool__(NewFileInfo);
|
|
} else {
|
|
// if we can't release FileInfo
|
|
// restore pointers to Fcb & CommonFcb in
|
|
// FileInfo & Dloc
|
|
NewFileInfo->Fcb = PtrNewFcb;
|
|
if(NtReqFcb)
|
|
NewFileInfo->Dloc->CommonFcb = NtReqFcb;
|
|
}
|
|
// forget about last FileInfo & Fcb,
|
|
// further unwind staff needs only last good
|
|
// structures
|
|
PtrNewFcb = NULL;
|
|
NewFileInfo = NULL;
|
|
}
|
|
}
|
|
|
|
// should return error if 'delete in progress'
|
|
if(LastGoodFileInfo->Fcb->FCBFlags & (UDF_FCB_DELETE_ON_CLOSE |
|
|
UDF_FCB_DELETED |
|
|
UDF_FCB_POSTED_RENAME)) {
|
|
AdPrint((" Return DeletePending (no err)\n"));
|
|
try_return(RC = STATUS_DELETE_PENDING);
|
|
}
|
|
// update last good state information...
|
|
OldRelatedFileInfo = RelatedFileInfo;
|
|
RelatedFileInfo = NewFileInfo;
|
|
// ...and go to the next open cycle
|
|
} else {
|
|
// ************
|
|
if(StreamOpen && (RC == STATUS_NOT_FOUND))
|
|
// handle SDir return code
|
|
RC = STATUS_OBJECT_NAME_NOT_FOUND;
|
|
if(RC == STATUS_OBJECT_NAME_NOT_FOUND) {
|
|
// good path, but no such file.... Amen
|
|
// break open loop and continue with Create
|
|
break;
|
|
}
|
|
if (!NT_SUCCESS(RC)) {
|
|
// Hard error or damaged data structures ...
|
|
#ifdef UDF_DBG
|
|
if((RC != STATUS_OBJECT_PATH_NOT_FOUND) &&
|
|
(RC != STATUS_ACCESS_DENIED) &&
|
|
(RC != STATUS_NOT_A_DIRECTORY)) {
|
|
AdPrint((" Hard error or damaged data structures\n"));
|
|
}
|
|
#endif // UDF_DBG
|
|
// ... and exit with error
|
|
try_return(RC);
|
|
}
|
|
// discard changes for last successfully opened file
|
|
UDFInterlockedDecrement((PLONG)&(PtrNewFcb->ReferenceCount));
|
|
UDFInterlockedDecrement((PLONG)&(PtrNewFcb->NTRequiredFCB->CommonRefCount));
|
|
RC = STATUS_SUCCESS;
|
|
ASSERT(!OpenTargetDirectory);
|
|
// break open loop and continue with Open
|
|
// (Create will be skipped)
|
|
break;
|
|
}
|
|
} // end of while(TRUE)
|
|
|
|
// ****************
|
|
// If "open target directory" was specified
|
|
// ****************
|
|
if(OpenTargetDirectory) {
|
|
|
|
if(!UDFIsADirectory(LastGoodFileInfo)) {
|
|
AdPrint((" Not a directory (2)\n"));
|
|
RC = STATUS_NOT_A_DIRECTORY;
|
|
}
|
|
if(!NT_SUCCESS(RC) ||
|
|
TailName.Length) {
|
|
AdPrint((" Target name should not contain (back)slashes\n"));
|
|
NewFileInfo = NULL;
|
|
try_return(RC = STATUS_OBJECT_NAME_INVALID);
|
|
}
|
|
|
|
NewFileInfo = LastGoodFileInfo;
|
|
RtlCopyUnicodeString(&(PtrNewFileObject->FileName), &CurName);
|
|
|
|
// now we have to check if last component exists...
|
|
if(NT_SUCCESS(RC = UDFFindFile__(Vcb, IgnoreCase,
|
|
&CurName, RelatedFileInfo))) {
|
|
// file exists, set this information in the Information field
|
|
ReturnedInformation = FILE_EXISTS;
|
|
AdPrint((" Open Target: FILE_EXISTS\n"));
|
|
} else
|
|
if(RC == STATUS_OBJECT_NAME_NOT_FOUND) {
|
|
#ifdef UDF_DBG
|
|
// check name. If there are '\\'s in TailName, some
|
|
// directories in path specified do not exist
|
|
for(TmpBuffer = LastGoodTail.Buffer; *TmpBuffer; TmpBuffer++) {
|
|
if((*TmpBuffer) == L'\\') {
|
|
ASSERT(FALSE);
|
|
AdPrint((" Target name should not contain (back)slashes\n"));
|
|
try_return(RC = STATUS_OBJECT_NAME_INVALID);
|
|
}
|
|
}
|
|
#endif // UDF_DBG
|
|
// Tell the I/O Manager that file does not exit
|
|
ReturnedInformation = FILE_DOES_NOT_EXIST;
|
|
AdPrint((" Open Target: FILE_DOES_NOT_EXIST\n"));
|
|
RC = STATUS_SUCCESS; // is already set here
|
|
} else {
|
|
AdPrint((" Open Target: unexpected error\n"));
|
|
NewFileInfo = NULL;
|
|
ReturnedInformation = FILE_DOES_NOT_EXIST;
|
|
try_return(RC = STATUS_OBJECT_NAME_INVALID);
|
|
}
|
|
|
|
// RC = STATUS_SUCCESS; // is already set here
|
|
|
|
// Update the file object FsContext and FsContext2 fields
|
|
// to reflect the fact that the parent directory of the
|
|
// target has been opened
|
|
PtrNewFcb = NewFileInfo->Fcb;
|
|
UDFInterlockedDecrement((PLONG)&(PtrNewFcb->ReferenceCount));
|
|
UDFInterlockedDecrement((PLONG)&(PtrNewFcb->NTRequiredFCB->CommonRefCount));
|
|
RC = UDFOpenFile(Vcb, PtrNewFileObject, PtrNewFcb);
|
|
ASSERT_REF(PtrNewFcb->ReferenceCount >= NewFileInfo->RefCount);
|
|
if (!NT_SUCCESS(RC)) {
|
|
AdPrint((" Can't perform OpenFile operation for target\n"));
|
|
try_return(RC);
|
|
}
|
|
PtrNewCcb = (PtrUDFCCB)(PtrNewFileObject->FsContext2);
|
|
|
|
ASSERT(Res1);
|
|
RC = UDFCheckAccessRights(PtrNewFileObject, AccessState, PtrNewFcb, PtrNewCcb, DesiredAccess, ShareAccess);
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Access/Share access check failed (Open Target)\n"));
|
|
}
|
|
|
|
try_return(RC);
|
|
}
|
|
|
|
// ****************
|
|
// should we CREATE a new file ?
|
|
// ****************
|
|
if (!NT_SUCCESS(RC)) {
|
|
if (RC == STATUS_OBJECT_NAME_NOT_FOUND ||
|
|
RC == STATUS_OBJECT_PATH_NOT_FOUND) {
|
|
if( ((RequestedDisposition == FILE_OPEN) ||
|
|
(RequestedDisposition == FILE_OVERWRITE)) /*&&
|
|
(!StreamOpen || !StreamExists)*/ ){
|
|
ReturnedInformation = FILE_DOES_NOT_EXIST;
|
|
AdPrint((" File doesn't exist\n"));
|
|
try_return(RC);
|
|
}
|
|
} else {
|
|
// Any other operation return STATUS_ACCESS_DENIED.
|
|
AdPrint((" Can't create due to unexpected error\n"));
|
|
try_return(RC);
|
|
}
|
|
// Object was not found, create if requested
|
|
if ((RequestedDisposition != FILE_CREATE) && (RequestedDisposition != FILE_OPEN_IF) &&
|
|
(RequestedDisposition != FILE_OVERWRITE_IF) && (RequestedDisposition != FILE_SUPERSEDE)) {
|
|
AdPrint((" File doesn't exist (2)\n"));
|
|
ReturnedInformation = FILE_DOES_NOT_EXIST;
|
|
try_return(RC);
|
|
}
|
|
// Check Volume ReadOnly attr
|
|
#ifndef UDF_READ_ONLY_BUILD
|
|
if((Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY)) {
|
|
#endif //UDF_READ_ONLY_BUILD
|
|
ReturnedInformation = 0;
|
|
AdPrint((" Write protected\n"));
|
|
try_return(RC = STATUS_MEDIA_WRITE_PROTECTED);
|
|
#ifndef UDF_READ_ONLY_BUILD
|
|
}
|
|
// Check r/o + delete on close
|
|
if(DeleteOnCloseSpecified &&
|
|
(FileAttributes & FILE_ATTRIBUTE_READONLY)) {
|
|
AdPrint((" Can't create r/o file marked for deletion\n"));
|
|
try_return(RC = STATUS_CANNOT_DELETE);
|
|
}
|
|
|
|
// Create a new file/directory here ...
|
|
if(StreamOpen)
|
|
StreamName.Buffer[StreamName.Length/sizeof(WCHAR)] = 0;
|
|
for(TmpBuffer = LastGoodTail.Buffer; *TmpBuffer; TmpBuffer++) {
|
|
if((*TmpBuffer) == L'\\') {
|
|
AdPrint((" Target name should not contain (back)slashes\n"));
|
|
try_return(RC = STATUS_OBJECT_NAME_INVALID);
|
|
}
|
|
}
|
|
if( DirectoryOnlyRequested &&
|
|
((IrpSp->Parameters.Create.FileAttributes & FILE_ATTRIBUTE_TEMPORARY) ||
|
|
StreamOpen || FALSE)) {
|
|
AdPrint((" Creation of _temporary_ directory not permited\n"));
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
}
|
|
// check access rights
|
|
ASSERT(Res1);
|
|
RC = UDFCheckAccessRights(NULL, NULL, OldRelatedFileInfo->Fcb, PtrRelatedCCB, DirectoryOnlyRequested ? FILE_ADD_SUBDIRECTORY : FILE_ADD_FILE, 0);
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Creation of File/Dir not permitted\n"));
|
|
try_return(RC);
|
|
}
|
|
// Note that a FCB structure will be allocated at this time
|
|
// and so will a CCB structure. Assume that these are called
|
|
// PtrNewFcb and PtrNewCcb respectively.
|
|
// Further, note that since the file is being created, no other
|
|
// thread can have the file stream open at this time.
|
|
RelatedFileInfo = OldRelatedFileInfo;
|
|
|
|
RC = UDFCreateFile__(Vcb, IgnoreCase, &LastGoodTail, 0, 0,
|
|
Vcb->UseExtendedFE || (StreamOpen && !StreamExists),
|
|
(RequestedDisposition == FILE_CREATE), RelatedFileInfo, &NewFileInfo);
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Creation error\n"));
|
|
Creation_Err_1:
|
|
if(NewFileInfo) {
|
|
PtrNewFcb = NewFileInfo->Fcb;
|
|
ASSERT(!PtrNewFcb);
|
|
if(PtrNewFcb &&
|
|
!PtrNewFcb->ReferenceCount &&
|
|
!PtrNewFcb->OpenHandleCount) {
|
|
NewFileInfo->Fcb = NULL;
|
|
}
|
|
if(NewFileInfo->Dloc &&
|
|
!NewFileInfo->Dloc->LinkRefCount) {
|
|
NewFileInfo->Dloc->CommonFcb = NULL;
|
|
}
|
|
if(UDFCleanUpFile__(Vcb, NewFileInfo)) {
|
|
if(PtrNewFcb) {
|
|
BrutePoint();
|
|
UDFCleanUpFCB(PtrNewFcb);
|
|
}
|
|
MyFreePool__(NewFileInfo);
|
|
PtrNewFcb = PtrNewFcb;
|
|
} else {
|
|
NewFileInfo->Fcb = PtrNewFcb;
|
|
}
|
|
PtrNewFcb = NULL;
|
|
}
|
|
try_return(RC);
|
|
}
|
|
// Update parent object
|
|
if((Vcb->CompatFlags & UDF_VCB_IC_UPDATE_DIR_WRITE) &&
|
|
PtrRelatedFCB &&
|
|
PtrRelatedFileObject &&
|
|
(PtrRelatedFCB->FileInfo == NewFileInfo->ParentFile)) {
|
|
PtrRelatedFileObject->Flags |= (FO_FILE_MODIFIED | FO_FILE_SIZE_CHANGED);
|
|
}
|
|
#if 0
|
|
CollectStatistics(Vcb, MetaDataWrites);
|
|
#endif
|
|
|
|
if(DirectoryOnlyRequested) {
|
|
// user wants the directory to be created
|
|
RC = UDFRecordDirectory__(Vcb, NewFileInfo);
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Can't transform to directory\n"));
|
|
Undo_Create_1:
|
|
if((RC != STATUS_FILE_IS_A_DIRECTORY) &&
|
|
(RC != STATUS_NOT_A_DIRECTORY) &&
|
|
(RC != STATUS_ACCESS_DENIED)) {
|
|
UDFFlushFile__(Vcb, NewFileInfo);
|
|
UDFUnlinkFile__(Vcb, NewFileInfo, TRUE);
|
|
}
|
|
UDFCloseFile__(Vcb, NewFileInfo);
|
|
BrutePoint();
|
|
goto Creation_Err_1;
|
|
}
|
|
#if 0
|
|
CollectStatistics(Vcb, MetaDataWrites);
|
|
#endif
|
|
} else if(AllocationSize) {
|
|
// set initial file size
|
|
/* if(!NT_SUCCESS(RC = UDFResizeFile__(Vcb, NewFileInfo, AllocationSize))) {
|
|
AdPrint((" Can't set initial file size\n"));
|
|
goto Undo_Create_1;
|
|
}
|
|
CollectStatistics(Vcb, MetaDataWrites);*/
|
|
}
|
|
|
|
if(StreamOpen && !StreamExists) {
|
|
|
|
// PHASE 0
|
|
|
|
// Open the newly created object (file)
|
|
if (!(PtrNewFcb = NewFileInfo->Fcb)) {
|
|
// It is a first open operation
|
|
// Allocate new FCB
|
|
// Here we set FileObject pointer to NULL to avoid
|
|
// new CCB allocation
|
|
RC = UDFFirstOpenFile(Vcb,
|
|
NULL, &PtrNewFcb, RelatedFileInfo, NewFileInfo,
|
|
&LocalPath, &LastGoodTail);
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Can't perform FirstOpenFile operation for file to contain stream\n"));
|
|
BrutePoint();
|
|
UDFCleanUpFCB(NewFileInfo->Fcb);
|
|
NewFileInfo->Fcb = NULL;
|
|
goto Creation_Err_1;
|
|
}
|
|
} else {
|
|
BrutePoint();
|
|
}
|
|
|
|
// Update unwind information
|
|
TreeLength++;
|
|
LastGoodFileInfo = NewFileInfo;
|
|
// update FCB tree
|
|
RC = MyAppendUnicodeToString(&LocalPath, L"\\");
|
|
if(!NT_SUCCESS(RC)) try_return(RC);
|
|
RC = MyAppendUnicodeStringToStringTag(&LocalPath, &LastGoodTail, MEM_USLOC_TAG);
|
|
if(!NT_SUCCESS(RC))
|
|
goto Creation_Err_1;
|
|
UDFInterlockedIncrement((PLONG)&(PtrNewFcb->ReferenceCount));
|
|
UDFInterlockedIncrement((PLONG)&(PtrNewFcb->NTRequiredFCB->CommonRefCount));
|
|
ASSERT_REF(PtrNewFcb->ReferenceCount >= NewFileInfo->RefCount);
|
|
PtrNewFcb->NTRequiredFCB->NtReqFCBFlags |= UDF_NTREQ_FCB_VALID;
|
|
PtrNewFcb->FCBFlags |= UDF_FCB_VALID;
|
|
|
|
UDFNotifyFullReportChange( Vcb, NewFileInfo,
|
|
UDFIsADirectory(NewFileInfo) ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME,
|
|
FILE_ACTION_ADDED);
|
|
|
|
// PHASE 1
|
|
|
|
// we need to create Stream Dir
|
|
RelatedFileInfo = NewFileInfo;
|
|
RC = UDFCreateStreamDir__(Vcb, RelatedFileInfo, &NewFileInfo);
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Can't create SDir\n"));
|
|
BrutePoint();
|
|
goto Creation_Err_1;
|
|
}
|
|
#if 0
|
|
CollectStatistics(Vcb, MetaDataWrites);
|
|
#endif
|
|
|
|
// normalize stream name
|
|
StreamName.Buffer++;
|
|
StreamName.Length-=sizeof(WCHAR);
|
|
// Open the newly created object
|
|
if (!(PtrNewFcb = NewFileInfo->Fcb)) {
|
|
// It is a first open operation
|
|
// Allocate new FCB
|
|
// Here we set FileObject pointer to NULL to avoid
|
|
// new CCB allocation
|
|
RC = UDFFirstOpenFile(Vcb,
|
|
NULL, &PtrNewFcb, RelatedFileInfo, NewFileInfo,
|
|
&LocalPath, &(UDFGlobalData.UnicodeStrSDir));
|
|
} else {
|
|
BrutePoint();
|
|
}
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Can't perform OpenFile operation for SDir\n"));
|
|
BrutePoint();
|
|
goto Creation_Err_1;
|
|
}
|
|
|
|
// Update unwind information
|
|
TreeLength++;
|
|
LastGoodFileInfo = NewFileInfo;
|
|
// update FCB tree
|
|
RC = MyAppendUnicodeStringToStringTag(&LocalPath, &(UDFGlobalData.UnicodeStrSDir), MEM_USLOC_TAG);
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Can't append UNC str\n"));
|
|
BrutePoint();
|
|
goto Creation_Err_1;
|
|
}
|
|
UDFInterlockedIncrement((PLONG)&(PtrNewFcb->ReferenceCount));
|
|
UDFInterlockedIncrement((PLONG)&(PtrNewFcb->NTRequiredFCB->CommonRefCount));
|
|
ASSERT_REF(PtrNewFcb->ReferenceCount >= NewFileInfo->RefCount);
|
|
PtrNewFcb->NTRequiredFCB->NtReqFCBFlags |= UDF_NTREQ_FCB_VALID;
|
|
PtrNewFcb->FCBFlags |= UDF_FCB_VALID;
|
|
|
|
// PHASE 2
|
|
|
|
// create stream
|
|
RelatedFileInfo = NewFileInfo;
|
|
RC = UDFCreateFile__(Vcb, IgnoreCase, &StreamName, 0, 0,
|
|
Vcb->UseExtendedFE, (RequestedDisposition == FILE_CREATE),
|
|
RelatedFileInfo, &NewFileInfo);
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Can't create Stream\n"));
|
|
BrutePoint();
|
|
goto Creation_Err_1;
|
|
}
|
|
#if 0
|
|
CollectStatistics(Vcb, MetaDataWrites);
|
|
#endif
|
|
|
|
// Update unwind information
|
|
LastGoodTail = StreamName;
|
|
}
|
|
// NT wants ARCHIVE bit to be set on Files
|
|
if(!DirectoryOnlyRequested)
|
|
FileAttributes |= FILE_ATTRIBUTE_ARCHIVE;
|
|
// Open the newly created object
|
|
if (!(PtrNewFcb = NewFileInfo->Fcb)) {
|
|
// It is a first open operation
|
|
#ifndef IFS_40
|
|
// Set attributes for the file ...
|
|
UDFAttributesToUDF(UDFDirIndex(UDFGetDirIndexByFileInfo(NewFileInfo),NewFileInfo->Index),
|
|
NewFileInfo->Dloc->FileEntry, FileAttributes);
|
|
#endif //IFS_40
|
|
// Allocate new FCB
|
|
// Here we set FileObject pointer to NULL to avoid
|
|
// new CCB allocation
|
|
RC = UDFFirstOpenFile(Vcb,
|
|
PtrNewFileObject, &PtrNewFcb, RelatedFileInfo, NewFileInfo,
|
|
&LocalPath, &LastGoodTail);
|
|
} else {
|
|
BrutePoint();
|
|
}
|
|
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Can't perform OpenFile operation for file or stream\n"));
|
|
BrutePoint();
|
|
goto Undo_Create_1;
|
|
}
|
|
|
|
PtrNewFcb->NTRequiredFCB->CommonFCBHeader.FileSize.QuadPart =
|
|
PtrNewFcb->NTRequiredFCB->CommonFCBHeader.ValidDataLength.QuadPart = 0;
|
|
if(AllocationSize) {
|
|
// inform NT about size changes
|
|
PtrNewFcb->NTRequiredFCB->CommonFCBHeader.AllocationSize.QuadPart = AllocationSize;
|
|
MmPrint((" CcIsFileCached()\n"));
|
|
if(CcIsFileCached(PtrNewFileObject)) {
|
|
MmPrint((" CcSetFileSizes()\n"));
|
|
BrutePoint();
|
|
CcSetFileSizes(PtrNewFileObject, (PCC_FILE_SIZES)&(PtrNewFcb->NTRequiredFCB->CommonFCBHeader.AllocationSize));
|
|
PtrNewFcb->NTRequiredFCB->NtReqFCBFlags |= UDF_NTREQ_FCB_MODIFIED;
|
|
}
|
|
}
|
|
|
|
// Update unwind information
|
|
TreeLength++;
|
|
LastGoodFileInfo = NewFileInfo;
|
|
|
|
// Set the Share Access for the file stream.
|
|
// The FCBShareAccess field will be set by the I/O Manager.
|
|
PtrNewCcb = (PtrUDFCCB)(PtrNewFileObject->FsContext2);
|
|
RC = UDFSetAccessRights(PtrNewFileObject, AccessState, PtrNewFcb, PtrNewCcb, DesiredAccess, ShareAccess);
|
|
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Can't set Access Rights on Create\n"));
|
|
BrutePoint();
|
|
UDFFlushFile__(Vcb, NewFileInfo);
|
|
UDFUnlinkFile__(Vcb, NewFileInfo, TRUE);
|
|
try_return(RC);
|
|
}
|
|
|
|
#ifdef IFS_40
|
|
// Set attributes for the file ...
|
|
UDFAttributesToUDF(UDFDirIndex(UDFGetDirIndexByFileInfo(NewFileInfo),NewFileInfo->Index),
|
|
NewFileInfo->Dloc->FileEntry, FileAttributes);
|
|
// It is rather strange for me, but NT requires us to allow
|
|
// Create operation for r/o + WriteAccess, but denies all
|
|
// the rest operations in this case. Thus, we should update
|
|
// r/o flag in Fcb _after_ Access check :-/
|
|
if(FileAttributes & FILE_ATTRIBUTE_READONLY)
|
|
PtrNewFcb->FCBFlags |= UDF_FCB_READ_ONLY;
|
|
#endif //IFS_40
|
|
// We call the notify package to report that the
|
|
// we have added a stream.
|
|
if(UDFIsAStream(NewFileInfo)) {
|
|
UDFNotifyFullReportChange( Vcb, NewFileInfo,
|
|
FILE_NOTIFY_CHANGE_STREAM_NAME,
|
|
FILE_ACTION_ADDED_STREAM );
|
|
} else {
|
|
UDFNotifyFullReportChange( Vcb, NewFileInfo,
|
|
UDFIsADirectory(NewFileInfo) ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME,
|
|
FILE_ACTION_ADDED);
|
|
}
|
|
/*#ifdef UDF_DBG
|
|
{
|
|
ULONG i;
|
|
PDIR_INDEX_HDR hDirIndex = NewFileInfo->ParentFile->Dloc->DirIndex;
|
|
|
|
for(i=0;DirIndex[i].FName.Buffer;i++) {
|
|
AdPrint(("%ws\n", DirIndex[i].FName.Buffer));
|
|
}
|
|
}
|
|
#endif*/
|
|
ReturnedInformation = FILE_CREATED;
|
|
|
|
try_return(RC);
|
|
#endif //UDF_READ_ONLY_BUILD
|
|
|
|
}
|
|
|
|
AlreadyOpened:
|
|
|
|
// ****************
|
|
// we have always STATUS_SUCCESS here
|
|
// ****************
|
|
|
|
ASSERT(NewFileInfo != OldRelatedFileInfo);
|
|
// A new CCB will be allocated.
|
|
// Assume that this structure named PtrNewCcb
|
|
RC = UDFOpenFile(Vcb, PtrNewFileObject, PtrNewFcb);
|
|
if (!NT_SUCCESS(RC)) try_return(RC);
|
|
PtrNewCcb = (PtrUDFCCB)(PtrNewFileObject->FsContext2);
|
|
|
|
if(RequestedDisposition == FILE_CREATE) {
|
|
ReturnedInformation = FILE_EXISTS;
|
|
AdPrint((" Object name collision\n"));
|
|
try_return(RC = STATUS_OBJECT_NAME_COLLISION);
|
|
}
|
|
|
|
NtReqFcb = PtrNewFcb->NTRequiredFCB;
|
|
NtReqFcb->CommonFCBHeader.IsFastIoPossible = UDFIsFastIoPossible(PtrNewFcb);
|
|
|
|
// Check if caller wanted a directory only and target object
|
|
// is not a directory, or caller wanted a file only and target
|
|
// object is not a file ...
|
|
if((PtrNewFcb->FCBFlags & UDF_FCB_DIRECTORY) && ((RequestedDisposition == FILE_SUPERSEDE) ||
|
|
(RequestedDisposition == FILE_OVERWRITE) || (RequestedDisposition == FILE_OVERWRITE_IF) ||
|
|
FileOnlyRequested)) {
|
|
if(FileOnlyRequested) {
|
|
AdPrint((" Can't open directory as a plain file\n"));
|
|
} else {
|
|
AdPrint((" Can't supersede directory\n"));
|
|
}
|
|
RC = STATUS_FILE_IS_A_DIRECTORY;
|
|
try_return(RC);
|
|
}
|
|
|
|
if(DirectoryOnlyRequested && !(PtrNewFcb->FCBFlags & UDF_FCB_DIRECTORY)) {
|
|
AdPrint((" This is not a directory\n"));
|
|
RC = STATUS_NOT_A_DIRECTORY;
|
|
try_return(RC);
|
|
}
|
|
|
|
if(DeleteOnCloseSpecified && (PtrNewFcb->FCBFlags & UDF_FCB_READ_ONLY)) {
|
|
AdPrint((" Can't delete Read-Only file\n"));
|
|
RC = STATUS_CANNOT_DELETE;
|
|
try_return(RC);
|
|
}
|
|
// Check share access and fail if the share conflicts with an existing
|
|
// open.
|
|
ASSERT(Res1 != NULL);
|
|
ASSERT(Res2 != NULL);
|
|
RC = UDFCheckAccessRights(PtrNewFileObject, AccessState, PtrNewFcb, PtrNewCcb, DesiredAccess, ShareAccess);
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Access/Share access check failed\n"));
|
|
try_return(RC);
|
|
}
|
|
|
|
RestoreShareAccess = TRUE;
|
|
|
|
if(FileOnlyRequested) {
|
|
// If the user wants 'write access' access to the file make sure there
|
|
// is not a process mapping this file as an image. Any attempt to
|
|
// delete the file will be stopped in fileinfo.cpp
|
|
//
|
|
// If the user wants to delete on close, we must check at this
|
|
// point though.
|
|
if( (DesiredAccess & FILE_WRITE_DATA) || DeleteOnCloseSpecified ) {
|
|
MmPrint((" MmFlushImageSection();\n"));
|
|
NtReqFcb->AcqFlushCount++;
|
|
if(!MmFlushImageSection( &(NtReqFcb->SectionObject),
|
|
MmFlushForWrite )) {
|
|
|
|
NtReqFcb->AcqFlushCount--;
|
|
RC = DeleteOnCloseSpecified ? STATUS_CANNOT_DELETE :
|
|
STATUS_SHARING_VIOLATION;
|
|
AdPrint((" File is mapped or deletion in progress\n"));
|
|
try_return (RC);
|
|
}
|
|
NtReqFcb->AcqFlushCount--;
|
|
}
|
|
if( NoBufferingSpecified &&
|
|
/* (PtrNewFileObject->Flags & FO_NO_INTERMEDIATE_BUFFERING) &&*/
|
|
!(PtrNewFcb->CachedOpenHandleCount) &&
|
|
(NtReqFcb->SectionObject.DataSectionObject) ) {
|
|
// If this is a non-cached open, and there are no open cached
|
|
// handles, but there is still a data section, attempt a flush
|
|
// and purge operation to avoid cache coherency overhead later.
|
|
// We ignore any I/O errors from the flush.
|
|
MmPrint((" CcFlushCache()\n"));
|
|
CcFlushCache( &(NtReqFcb->SectionObject), NULL, 0, NULL );
|
|
MmPrint((" CcPurgeCacheSection()\n"));
|
|
CcPurgeCacheSection( &(NtReqFcb->SectionObject), NULL, 0, FALSE );
|
|
}
|
|
}
|
|
|
|
if(DeleteOnCloseSpecified && UDFIsADirectory(NewFileInfo) && !UDFIsDirEmpty__(NewFileInfo)) {
|
|
AdPrint((" Directory in not empry\n"));
|
|
try_return (RC = STATUS_DIRECTORY_NOT_EMPTY);
|
|
}
|
|
|
|
// Get attributes for the file ...
|
|
TmpFileAttributes =
|
|
(USHORT)UDFAttributesToNT(UDFDirIndex(UDFGetDirIndexByFileInfo(NewFileInfo), NewFileInfo->Index),
|
|
NewFileInfo->Dloc->FileEntry);
|
|
|
|
if(DeleteOnCloseSpecified &&
|
|
(TmpFileAttributes & FILE_ATTRIBUTE_READONLY)) {
|
|
ASSERT(Res1 != NULL);
|
|
ASSERT(Res2 != NULL);
|
|
RC = UDFCheckAccessRights(NULL, NULL, OldRelatedFileInfo->Fcb, PtrRelatedCCB, FILE_DELETE_CHILD, 0);
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Read-only. DeleteOnClose attempt failed\n"));
|
|
try_return (RC = STATUS_CANNOT_DELETE);
|
|
}
|
|
}
|
|
|
|
// If a supersede or overwrite was requested, do so now ...
|
|
if((RequestedDisposition == FILE_SUPERSEDE) ||
|
|
(RequestedDisposition == FILE_OVERWRITE) ||
|
|
(RequestedDisposition == FILE_OVERWRITE_IF)) {
|
|
// Attempt the operation here ...
|
|
|
|
#ifndef UDF_READ_ONLY_BUILD
|
|
ASSERT(!UDFIsADirectory(NewFileInfo));
|
|
|
|
if(RequestedDisposition == FILE_SUPERSEDE) {
|
|
BOOLEAN RestoreRO = FALSE;
|
|
|
|
ASSERT(Res1 != NULL);
|
|
ASSERT(Res2 != NULL);
|
|
// NT wants us to allow Supersede on RO files
|
|
if(PtrNewFcb->FCBFlags & UDF_FCB_READ_ONLY) {
|
|
// Imagine, that file is not RO and check other permissions
|
|
RestoreRO = TRUE;
|
|
PtrNewFcb->FCBFlags &= ~UDF_FCB_READ_ONLY;
|
|
}
|
|
RC = UDFCheckAccessRights(NULL, NULL, PtrNewFcb, PtrNewCcb, DELETE, 0);
|
|
if(RestoreRO) {
|
|
// Restore RO state if changed
|
|
PtrNewFcb->FCBFlags |= UDF_FCB_READ_ONLY;
|
|
}
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Can't supersede. DELETE permission required\n"));
|
|
try_return (RC);
|
|
}
|
|
} else {
|
|
ASSERT(Res1 != NULL);
|
|
ASSERT(Res2 != NULL);
|
|
RC = UDFCheckAccessRights(NULL, NULL, PtrNewFcb, PtrNewCcb,
|
|
FILE_WRITE_DATA | FILE_WRITE_EA | FILE_WRITE_ATTRIBUTES, 0);
|
|
if(!NT_SUCCESS(RC)) {
|
|
AdPrint((" Can't overwrite. Permission denied\n"));
|
|
try_return (RC);
|
|
}
|
|
}
|
|
// Existing & requested System and Hidden bits must match
|
|
if( (TmpFileAttributes & (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)) &
|
|
(FileAttributes ^ (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)) ) {
|
|
AdPrint((" The Hidden and/or System bits do not match\n"));
|
|
try_return(RC = STATUS_ACCESS_DENIED);
|
|
}
|
|
|
|
// Before we actually truncate, check to see if the purge
|
|
// is going to fail.
|
|
MmPrint((" MmCanFileBeTruncated()\n"));
|
|
if (!MmCanFileBeTruncated( &NtReqFcb->SectionObject,
|
|
&(UDFGlobalData.UDFLargeZero) )) {
|
|
AdPrint((" Can't truncate. File is mapped\n"));
|
|
try_return(RC = STATUS_USER_MAPPED_FILE);
|
|
}
|
|
|
|
ASSERT(Res1 != NULL);
|
|
ASSERT(Res2 != NULL);
|
|
|
|
#if 0
|
|
CollectStatistics(Vcb, MetaDataWrites);
|
|
#endif
|
|
// Synchronize with PagingIo
|
|
UDFAcquireResourceExclusive(PagingIoRes = &(NtReqFcb->PagingIoResource),TRUE);
|
|
// Set file sizes
|
|
if(!NT_SUCCESS(RC = UDFResizeFile__(Vcb, NewFileInfo, 0))) {
|
|
AdPrint((" Error during resize operation\n"));
|
|
try_return(RC);
|
|
}
|
|
/* if(AllocationSize) {
|
|
if(!NT_SUCCESS(RC = UDFResizeFile__(Vcb, NewFileInfo, AllocationSize))) {
|
|
AdPrint((" Error during resize operation (2)\n"));
|
|
try_return(RC);
|
|
}
|
|
}*/
|
|
NtReqFcb->CommonFCBHeader.AllocationSize.QuadPart = UDFSysGetAllocSize(Vcb, AllocationSize);
|
|
NtReqFcb->CommonFCBHeader.FileSize.QuadPart =
|
|
NtReqFcb->CommonFCBHeader.ValidDataLength.QuadPart = 0 /*AllocationSize*/;
|
|
PtrNewFcb->FCBFlags &= ~UDF_FCB_DELAY_CLOSE;
|
|
MmPrint((" CcSetFileSizes()\n"));
|
|
CcSetFileSizes(PtrNewFileObject, (PCC_FILE_SIZES)&(NtReqFcb->CommonFCBHeader.AllocationSize));
|
|
NtReqFcb->NtReqFCBFlags |= UDF_NTREQ_FCB_MODIFIED;
|
|
// Release PagingIoResource
|
|
UDFReleaseResource(PagingIoRes);
|
|
PagingIoRes = NULL;
|
|
|
|
if(NT_SUCCESS(RC)) {
|
|
FileAttributes |= FILE_ATTRIBUTE_ARCHIVE;
|
|
if (RequestedDisposition == FILE_SUPERSEDE) {
|
|
// Set attributes for the file ...
|
|
UDFAttributesToUDF(UDFDirIndex(UDFGetDirIndexByFileInfo(NewFileInfo), NewFileInfo->Index),
|
|
NewFileInfo->Dloc->FileEntry, FileAttributes);
|
|
ReturnedInformation = FILE_SUPERSEDED;
|
|
} else {
|
|
// Get attributes for the file ...
|
|
FileAttributes |= TmpFileAttributes;
|
|
// Set attributes for the file ...
|
|
UDFAttributesToUDF(UDFDirIndex(UDFGetDirIndexByFileInfo(NewFileInfo), NewFileInfo->Index),
|
|
NewFileInfo->Dloc->FileEntry, FileAttributes);
|
|
ReturnedInformation = FILE_OVERWRITTEN;
|
|
}
|
|
}
|
|
// notify changes
|
|
UDFNotifyFullReportChange( Vcb, NewFileInfo,
|
|
FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_SIZE,
|
|
FILE_ACTION_MODIFIED);
|
|
|
|
// Update parent object
|
|
if((Vcb->CompatFlags & UDF_VCB_IC_UPDATE_DIR_WRITE) &&
|
|
PtrRelatedFCB &&
|
|
PtrRelatedFileObject &&
|
|
(PtrRelatedFCB->FileInfo == NewFileInfo->ParentFile)) {
|
|
PtrRelatedFileObject->Flags |= (FO_FILE_MODIFIED | FO_FILE_SIZE_CHANGED);
|
|
}
|
|
#else //UDF_READ_ONLY_BUILD
|
|
try_return(RC = STATUS_ACCESS_DENIED);
|
|
#endif //UDF_READ_ONLY_BUILD
|
|
} else {
|
|
ReturnedInformation = FILE_OPENED;
|
|
}
|
|
|
|
// Update parent object
|
|
if((Vcb->CompatFlags & UDF_VCB_IC_UPDATE_DIR_READ) &&
|
|
PtrRelatedFCB &&
|
|
PtrRelatedFileObject &&
|
|
(PtrRelatedFCB->FileInfo == NewFileInfo->ParentFile)) {
|
|
PtrRelatedFileObject->Flags |= FO_FILE_FAST_IO_READ;
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
// Complete the request unless we are here as part of unwinding
|
|
// when an exception condition was encountered, OR
|
|
// if the request has been deferred (i.e. posted for later handling)
|
|
|
|
if(RestoreVCBOpenCounter) {
|
|
UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
|
|
RestoreVCBOpenCounter = FALSE;
|
|
}
|
|
|
|
if (RC != STATUS_PENDING) {
|
|
// If any intermediate (directory) open operations were performed,
|
|
// implement the corresponding close (do *not* however close
|
|
// the target we have opened on behalf of the caller ...).
|
|
|
|
#if 0
|
|
if(NT_SUCCESS(RC)) {
|
|
CollectStatistics2(Vcb, SuccessfulCreates);
|
|
} else {
|
|
CollectStatistics2(Vcb, FailedCreates);
|
|
}
|
|
#endif
|
|
|
|
if (NT_SUCCESS(RC) && PtrNewFcb) {
|
|
// Update the file object such that:
|
|
// (a) the FsContext field points to the NTRequiredFCB field
|
|
// in the FCB
|
|
// (b) the FsContext2 field points to the CCB created as a
|
|
// result of the open operation
|
|
|
|
// If write-through was requested, then mark the file object
|
|
// appropriately
|
|
|
|
// directories are not cached
|
|
// so we should prevent flush attepmts on cleanup
|
|
if(!(PtrNewFcb->FCBFlags & UDF_FCB_DIRECTORY)) {
|
|
#ifndef UDF_READ_ONLY_BUILD
|
|
if(WriteThroughRequested) {
|
|
PtrNewFileObject->Flags |= FO_WRITE_THROUGH;
|
|
PtrNewFcb->FCBFlags |= UDF_FCB_WRITE_THROUGH;
|
|
MmPrint((" FO_WRITE_THROUGH\n"));
|
|
}
|
|
#endif //UDF_READ_ONLY_BUILD
|
|
if(SequentialIoRequested &&
|
|
!(Vcb->CompatFlags & UDF_VCB_IC_IGNORE_SEQUENTIAL_IO)) {
|
|
PtrNewFileObject->Flags |= FO_SEQUENTIAL_ONLY;
|
|
MmPrint((" FO_SEQUENTIAL_ONLY\n"));
|
|
#ifndef UDF_READ_ONLY_BUILD
|
|
if(Vcb->TargetDeviceObject->Characteristics & FILE_REMOVABLE_MEDIA) {
|
|
PtrNewFileObject->Flags &= ~FO_WRITE_THROUGH;
|
|
PtrNewFcb->FCBFlags &= ~UDF_FCB_WRITE_THROUGH;
|
|
MmPrint((" FILE_REMOVABLE_MEDIA + FO_SEQUENTIAL_ONLY => ~FO_WRITE_THROUGH\n"));
|
|
}
|
|
#endif //UDF_READ_ONLY_BUILD
|
|
if(PtrNewFcb->FileInfo) {
|
|
UDFSetFileAllocMode__(PtrNewFcb->FileInfo, EXTENT_FLAG_ALLOC_SEQUENTIAL);
|
|
}
|
|
}
|
|
if(NoBufferingSpecified) {
|
|
PtrNewFileObject->Flags |= FO_NO_INTERMEDIATE_BUFFERING;
|
|
MmPrint((" FO_NO_INTERMEDIATE_BUFFERING\n"));
|
|
} else {
|
|
PtrNewFileObject->Flags |= FO_CACHE_SUPPORTED;
|
|
MmPrint((" FO_CACHE_SUPPORTED\n"));
|
|
}
|
|
}
|
|
|
|
if((DesiredAccess & FILE_EXECUTE) /*&&
|
|
!(PtrNewFcb->FCBFlags & UDF_FCB_DIRECTORY)*/) {
|
|
MmPrint((" FO_FILE_FAST_IO_READ\n"));
|
|
PtrNewFileObject->Flags |= FO_FILE_FAST_IO_READ;
|
|
}
|
|
// All right. Now we can safely increment OpenHandleCount
|
|
UDFInterlockedIncrement((PLONG)&(Vcb->VCBHandleCount));
|
|
UDFInterlockedIncrement((PLONG)&(PtrNewFcb->OpenHandleCount));
|
|
|
|
if(PtrNewFileObject->Flags & FO_CACHE_SUPPORTED)
|
|
UDFInterlockedIncrement((PLONG)&(PtrNewFcb->CachedOpenHandleCount));
|
|
// Store some flags in CCB
|
|
if(PtrNewCcb) {
|
|
PtrNewCcb->TreeLength = TreeLength;
|
|
// delete on close
|
|
#ifndef UDF_READ_ONLY_BUILD
|
|
if(DeleteOnCloseSpecified) {
|
|
ASSERT(!(PtrNewFcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY));
|
|
PtrNewCcb->CCBFlags |= UDF_CCB_DELETE_ON_CLOSE;
|
|
}
|
|
#endif //UDF_READ_ONLY_BUILD
|
|
// case sensetivity
|
|
if(!IgnoreCase) {
|
|
// remember this for possible Rename/Move operation
|
|
PtrNewCcb->CCBFlags |= UDF_CCB_CASE_SENSETIVE;
|
|
PtrNewFileObject->Flags |= FO_OPENED_CASE_SENSITIVE;
|
|
}
|
|
if(IsFileObjectReadOnly(PtrNewFileObject)) {
|
|
UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCountRO));
|
|
PtrNewCcb->CCBFlags |= UDF_CCB_READ_ONLY;
|
|
}
|
|
} else {
|
|
BrutePoint();
|
|
}
|
|
// it was a stream...
|
|
if(StreamOpen)
|
|
PtrNewFileObject->Flags |= FO_STREAM_FILE;
|
|
// PtrNewCcb->CCBFlags |= UDF_CCB_VALID;
|
|
// increment the number of outstanding open operations on this
|
|
// logical volume (i.e. volume cannot be dismounted)
|
|
UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCount));
|
|
PtrNewFcb->NTRequiredFCB->NtReqFCBFlags |= UDF_NTREQ_FCB_VALID;
|
|
PtrNewFcb->FCBFlags |= UDF_FCB_VALID;
|
|
#ifdef UDF_DBG
|
|
// We have no FileInfo for Volume
|
|
if(PtrNewFcb->FileInfo) {
|
|
ASSERT_REF(PtrNewFcb->ReferenceCount >= PtrNewFcb->FileInfo->RefCount);
|
|
}
|
|
#endif // UDF_DBG
|
|
AdPrint((" FCB %x, CCB %x, FO %x, Flags %x\n", PtrNewFcb, PtrNewCcb, PtrNewFileObject, PtrNewFcb->FCBFlags));
|
|
|
|
UDFReleaseResFromCreate(&PagingIoRes, &Res1, &Res2);
|
|
|
|
} else if(!NT_SUCCESS(RC)) {
|
|
// Perform failure related post-processing now
|
|
if(RestoreShareAccess && NtReqFcb && PtrNewFileObject) {
|
|
IoRemoveShareAccess(PtrNewFileObject, &(NtReqFcb->FCBShareAccess));
|
|
}
|
|
UDFCleanUpCCB(PtrNewCcb);
|
|
if(PtrNewFileObject) {
|
|
PtrNewFileObject->FsContext2 = NULL;
|
|
}
|
|
// We have successfully opened LastGoodFileInfo,
|
|
// so mark it as VALID to avoid future troubles...
|
|
if(LastGoodFileInfo && LastGoodFileInfo->Fcb) {
|
|
LastGoodFileInfo->Fcb->FCBFlags |= UDF_FCB_VALID;
|
|
if(LastGoodFileInfo->Fcb->NTRequiredFCB) {
|
|
LastGoodFileInfo->Fcb->NTRequiredFCB->NtReqFCBFlags |= UDF_NTREQ_FCB_VALID;
|
|
}
|
|
}
|
|
// Release resources...
|
|
UDFReleaseResFromCreate(&PagingIoRes, &Res1, &Res2);
|
|
ASSERT(AcquiredVcb);
|
|
// close the chain
|
|
UDFCloseFileInfoChain(Vcb, LastGoodFileInfo, TreeLength, TRUE);
|
|
// cleanup FCBs (if any)
|
|
if( Vcb && (PtrNewFcb != Vcb->RootDirFCB) &&
|
|
LastGoodFileInfo ) {
|
|
UDFCleanUpFcbChain(Vcb, LastGoodFileInfo, TreeLength, TRUE);
|
|
} else {
|
|
ASSERT(!LastGoodFileInfo);
|
|
}
|
|
} else {
|
|
UDFReleaseResFromCreate(&PagingIoRes, &Res1, &Res2);
|
|
}
|
|
// As long as this unwinding is not being performed as a result of
|
|
// an exception condition, complete the IRP ...
|
|
if (!_SEH2_AbnormalTermination()) {
|
|
Irp->IoStatus.Status = RC;
|
|
Irp->IoStatus.Information = ReturnedInformation;
|
|
|
|
// complete the IRP
|
|
IoCompleteRequest(Irp, IO_DISK_INCREMENT);
|
|
// Free up the Irp Context
|
|
UDFReleaseIrpContext(PtrIrpContext);
|
|
}
|
|
} else {
|
|
UDFReleaseResFromCreate(&PagingIoRes, &Res1, &Res2);
|
|
}
|
|
|
|
if(AcquiredVcb) {
|
|
UDFReleaseResource(&(Vcb->VCBResource));
|
|
}
|
|
// free allocated tmp buffers (if any)
|
|
if(AbsolutePathName.Buffer)
|
|
MyFreePool__(AbsolutePathName.Buffer);
|
|
if(LocalPath.Buffer)
|
|
MyFreePool__(LocalPath.Buffer);
|
|
if(TailNameBuffer)
|
|
MyFreePool__(TailNameBuffer);
|
|
} _SEH2_END;
|
|
|
|
return(RC);
|
|
} // end UDFCommonCreate()
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFFirstOpenFile()
|
|
*
|
|
* Description:
|
|
* Perform first Open/Create initialization.
|
|
*
|
|
* Expected Interrupt Level (for execution) :
|
|
*
|
|
* IRQL_PASSIVE_LEVEL
|
|
*
|
|
* Return Value: STATUS_SUCCESS/Error
|
|
*
|
|
*************************************************************************/
|
|
NTSTATUS
|
|
UDFFirstOpenFile(
|
|
IN PVCB Vcb, // volume control block
|
|
IN PFILE_OBJECT PtrNewFileObject, // I/O Mgr. created file object
|
|
OUT PtrUDFFCB* PtrNewFcb,
|
|
IN PUDF_FILE_INFO RelatedFileInfo,
|
|
IN PUDF_FILE_INFO NewFileInfo,
|
|
IN PUNICODE_STRING LocalPath,
|
|
IN PUNICODE_STRING CurName
|
|
)
|
|
{
|
|
// DIR_INDEX NewFileIndex;
|
|
PtrUDFObjectName NewFCBName;
|
|
PtrUDFNTRequiredFCB NtReqFcb;
|
|
NTSTATUS RC;
|
|
BOOLEAN Linked = TRUE;
|
|
PDIR_INDEX_HDR hDirIndex;
|
|
PDIR_INDEX_ITEM DirIndex;
|
|
|
|
AdPrint(("UDFFirstOpenFile\n"));
|
|
|
|
if(!((*PtrNewFcb) = UDFAllocateFCB())) {
|
|
AdPrint(("Can't allocate FCB\n"));
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
// Allocate and set new FCB unique name (equal to absolute path name)
|
|
if(!(NewFCBName = UDFAllocateObjectName())) return STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
if(RelatedFileInfo && RelatedFileInfo->Fcb &&
|
|
!(RelatedFileInfo->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY)) {
|
|
RC = MyCloneUnicodeString(&(NewFCBName->ObjectName), &(RelatedFileInfo->Fcb->FCBName->ObjectName));
|
|
} else {
|
|
RC = MyInitUnicodeString(&(NewFCBName->ObjectName), L"");
|
|
}
|
|
if(!NT_SUCCESS(RC))
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
if( (CurName->Buffer[0] != L':') &&
|
|
(!LocalPath->Length ||
|
|
((LocalPath->Buffer[LocalPath->Length/sizeof(WCHAR)-1] != L':') /*&&
|
|
(LocalPath->Buffer[LocalPath->Length/sizeof(WCHAR)-1] != L'\\')*/) )) {
|
|
RC = MyAppendUnicodeToString(&(NewFCBName->ObjectName), L"\\");
|
|
if(!NT_SUCCESS(RC)) {
|
|
UDFReleaseObjectName(NewFCBName);
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
}
|
|
|
|
// Make link between Fcb and FileInfo
|
|
(*PtrNewFcb)->FileInfo = NewFileInfo;
|
|
NewFileInfo->Fcb = (*PtrNewFcb);
|
|
(*PtrNewFcb)->ParentFcb = RelatedFileInfo->Fcb;
|
|
|
|
if(!((*PtrNewFcb)->NTRequiredFCB = NewFileInfo->Dloc->CommonFcb)) {
|
|
(*PtrNewFcb)->NTRequiredFCB = (PtrUDFNTRequiredFCB)MyAllocatePool__(NonPagedPool, UDFQuadAlign(sizeof(UDFNTRequiredFCB)));
|
|
if(!((*PtrNewFcb)->NTRequiredFCB)) {
|
|
UDFReleaseObjectName(NewFCBName);
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
UDFPrint(("UDFAllocateNtReqFCB: %x\n", (*PtrNewFcb)->NTRequiredFCB));
|
|
RtlZeroMemory((*PtrNewFcb)->NTRequiredFCB, UDFQuadAlign(sizeof(UDFNTRequiredFCB)));
|
|
(*PtrNewFcb)->FileInfo->Dloc->CommonFcb = (*PtrNewFcb)->NTRequiredFCB;
|
|
Linked = FALSE;
|
|
} else {
|
|
if(!(NewFileInfo->Dloc->CommonFcb->NtReqFCBFlags & UDF_NTREQ_FCB_VALID)) {
|
|
(*PtrNewFcb)->NTRequiredFCB = NULL;
|
|
BrutePoint();
|
|
UDFReleaseObjectName(NewFCBName);
|
|
return STATUS_ACCESS_DENIED;
|
|
}
|
|
}
|
|
|
|
NtReqFcb = (*PtrNewFcb)->NTRequiredFCB;
|
|
// Set times
|
|
if(!Linked) {
|
|
UDFGetFileXTime((*PtrNewFcb)->FileInfo,
|
|
&(NtReqFcb->CreationTime.QuadPart),
|
|
&(NtReqFcb->LastAccessTime.QuadPart),
|
|
&(NtReqFcb->ChangeTime.QuadPart),
|
|
&(NtReqFcb->LastWriteTime.QuadPart) );
|
|
|
|
// Set the allocation size for the object is specified
|
|
NtReqFcb->CommonFCBHeader.AllocationSize.QuadPart =
|
|
UDFSysGetAllocSize(Vcb, NewFileInfo->Dloc->DataLoc.Length);
|
|
// NtReqFcb->CommonFCBHeader.AllocationSize.QuadPart = UDFGetFileAllocationSize(Vcb, NewFileInfo);
|
|
NtReqFcb->CommonFCBHeader.FileSize.QuadPart =
|
|
NtReqFcb->CommonFCBHeader.ValidDataLength.QuadPart = NewFileInfo->Dloc->DataLoc.Length;
|
|
}
|
|
// begin transaction
|
|
UDFAcquireResourceExclusive(&(Vcb->FcbListResource), TRUE);
|
|
|
|
RC = UDFInitializeFCB(*PtrNewFcb, Vcb, NewFCBName,
|
|
UDFIsADirectory(NewFileInfo) ? UDF_FCB_DIRECTORY : 0, PtrNewFileObject);
|
|
if(!NT_SUCCESS(RC)) {
|
|
if(!Linked) {
|
|
MyFreePool__((*PtrNewFcb)->NTRequiredFCB);
|
|
(*PtrNewFcb)->NTRequiredFCB = NULL;
|
|
}
|
|
UDFReleaseResource(&(Vcb->FcbListResource));
|
|
return RC;
|
|
}
|
|
// set Read-only attribute
|
|
if(!UDFIsAStreamDir(NewFileInfo)) {
|
|
hDirIndex = UDFGetDirIndexByFileInfo(NewFileInfo);
|
|
#ifdef UDF_DBG
|
|
if(!hDirIndex) {
|
|
BrutePoint();
|
|
} else {
|
|
#endif // UDF_DBG
|
|
if(UDFAttributesToNT(DirIndex = UDFDirIndex(hDirIndex, NewFileInfo->Index),NULL) & FILE_ATTRIBUTE_READONLY) {
|
|
(*PtrNewFcb)->FCBFlags |= UDF_FCB_READ_ONLY;
|
|
}
|
|
MyAppendUnicodeStringToStringTag(&(NewFCBName->ObjectName), &(DirIndex->FName), MEM_USOBJ_TAG);
|
|
#ifdef UDF_DBG
|
|
}
|
|
#endif // UDF_DBG
|
|
} else if (RelatedFileInfo->ParentFile) {
|
|
hDirIndex = UDFGetDirIndexByFileInfo(RelatedFileInfo);
|
|
if(UDFAttributesToNT(DirIndex = UDFDirIndex(hDirIndex, RelatedFileInfo->Index),NULL) & FILE_ATTRIBUTE_READONLY) {
|
|
(*PtrNewFcb)->FCBFlags |= UDF_FCB_READ_ONLY;
|
|
}
|
|
RC = MyAppendUnicodeStringToStringTag(&(NewFCBName->ObjectName), CurName, MEM_USOBJ_TAG);
|
|
// } else {
|
|
// BrutePoint();
|
|
}
|
|
// do not allocate CCB if it is internal Create/Open
|
|
if(NT_SUCCESS(RC)) {
|
|
if(PtrNewFileObject) {
|
|
RC = UDFOpenFile(Vcb, PtrNewFileObject, *PtrNewFcb);
|
|
} else {
|
|
RC = STATUS_SUCCESS;
|
|
}
|
|
}
|
|
UDFReleaseResource(&(Vcb->FcbListResource));
|
|
// end transaction
|
|
|
|
// if(!NT_SUCCESS(RC)) return RC;
|
|
|
|
return RC;
|
|
} // end UDFFirstOpenFile()
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFOpenFile()
|
|
*
|
|
* Description:
|
|
* Open a file/dir for the caller.
|
|
*
|
|
* Expected Interrupt Level (for execution) :
|
|
*
|
|
* IRQL_PASSIVE_LEVEL
|
|
*
|
|
* Return Value: STATUS_SUCCESS/Error
|
|
*
|
|
*************************************************************************/
|
|
NTSTATUS
|
|
UDFOpenFile(
|
|
PVCB Vcb, // volume control block
|
|
PFILE_OBJECT PtrNewFileObject, // I/O Mgr. created file object
|
|
PtrUDFFCB PtrNewFcb
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PtrUDFCCB Ccb = NULL;
|
|
PtrUDFNTRequiredFCB NtReqFcb;
|
|
|
|
AdPrint(("UDFOpenFile\n"));
|
|
ASSERT((PtrNewFcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_FCB)
|
|
||(PtrNewFcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB));
|
|
|
|
_SEH2_TRY {
|
|
|
|
#if 0
|
|
CollectStatistics2(Vcb, CreateHits);
|
|
#endif
|
|
// create a new CCB structure
|
|
if (!(Ccb = UDFAllocateCCB())) {
|
|
AdPrint(("Can't allocate CCB\n"));
|
|
PtrNewFileObject->FsContext2 = NULL;
|
|
//
|
|
UDFInterlockedIncrement((PLONG)&(PtrNewFcb->ReferenceCount));
|
|
UDFInterlockedIncrement((PLONG)&(PtrNewFcb->NTRequiredFCB->CommonRefCount));
|
|
RC = STATUS_INSUFFICIENT_RESOURCES;
|
|
try_return(RC);
|
|
}
|
|
// initialize the CCB
|
|
Ccb->Fcb = PtrNewFcb;
|
|
// initialize the CCB to point to the file object
|
|
Ccb->FileObject = PtrNewFileObject;
|
|
|
|
// initialize the file object appropriately
|
|
PtrNewFileObject->FsContext2 = (PVOID)(Ccb);
|
|
PtrNewFileObject->Vpb = Vcb->Vpb;
|
|
PtrNewFileObject->FsContext = (PVOID)(NtReqFcb = PtrNewFcb->NTRequiredFCB);
|
|
PtrNewFileObject->SectionObjectPointer = &(NtReqFcb->SectionObject);
|
|
#ifdef DBG
|
|
// NtReqFcb ->FileObject = PtrNewFileObject;
|
|
#endif //DBG
|
|
|
|
#ifdef UDF_DELAYED_CLOSE
|
|
PtrNewFcb->FCBFlags &= ~UDF_FCB_DELAY_CLOSE;
|
|
#endif //UDF_DELAYED_CLOSE
|
|
|
|
UDFAcquireResourceExclusive(&(PtrNewFcb->CcbListResource),TRUE);
|
|
// insert CCB into linked list of open file object to Fcb or
|
|
// to Vcb and do other intialization
|
|
InsertTailList(&(PtrNewFcb->NextCCB), &(Ccb->NextCCB));
|
|
UDFInterlockedIncrement((PLONG)&(PtrNewFcb->ReferenceCount));
|
|
UDFInterlockedIncrement((PLONG)&(PtrNewFcb->NTRequiredFCB->CommonRefCount));
|
|
UDFReleaseResource(&(PtrNewFcb->CcbListResource));
|
|
|
|
try_exit: NOTHING;
|
|
} _SEH2_FINALLY {
|
|
NOTHING;
|
|
} _SEH2_END;
|
|
|
|
return(RC);
|
|
} // end UDFOpenFile()
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFInitializeFCB()
|
|
*
|
|
* Description:
|
|
* Initialize a new FCB structure and also the sent-in file object
|
|
* (if supplied)
|
|
*
|
|
* Expected Interrupt Level (for execution) :
|
|
*
|
|
* IRQL_PASSIVE_LEVEL
|
|
*
|
|
* Return Value: None
|
|
*
|
|
*************************************************************************/
|
|
NTSTATUS
|
|
UDFInitializeFCB(
|
|
IN PtrUDFFCB PtrNewFcb, // FCB structure to be initialized
|
|
IN PVCB Vcb, // logical volume (VCB) pointer
|
|
IN PtrUDFObjectName PtrObjectName, // name of the object
|
|
IN ULONG Flags, // is this a file/directory, etc.
|
|
IN PFILE_OBJECT FileObject) // optional file object to be initialized
|
|
{
|
|
AdPrint(("UDFInitializeFCB\n"));
|
|
NTSTATUS status;
|
|
BOOLEAN Linked = TRUE;
|
|
|
|
if(!PtrNewFcb->NTRequiredFCB->CommonFCBHeader.Resource) {
|
|
// record signature
|
|
PtrNewFcb->NTRequiredFCB->CommonFCBHeader.NodeTypeCode = UDF_NODE_TYPE_NT_REQ_FCB;
|
|
PtrNewFcb->NTRequiredFCB->CommonFCBHeader.NodeByteSize = sizeof(UDFNTRequiredFCB);
|
|
// Initialize the ERESOURCE objects
|
|
if(!NT_SUCCESS(status = UDFInitializeResourceLite(&(PtrNewFcb->NTRequiredFCB->MainResource)))) {
|
|
AdPrint((" Can't init resource\n"));
|
|
return status;
|
|
}
|
|
if(!NT_SUCCESS(status = UDFInitializeResourceLite(&(PtrNewFcb->NTRequiredFCB->PagingIoResource)))) {
|
|
AdPrint((" Can't init resource (2)\n"));
|
|
UDFDeleteResource(&(PtrNewFcb->NTRequiredFCB->MainResource));
|
|
return status;
|
|
}
|
|
// Fill NT required Fcb part
|
|
PtrNewFcb->NTRequiredFCB->CommonFCBHeader.Resource = &(PtrNewFcb->NTRequiredFCB->MainResource);
|
|
PtrNewFcb->NTRequiredFCB->CommonFCBHeader.PagingIoResource = &(PtrNewFcb->NTRequiredFCB->PagingIoResource);
|
|
// Itialize byte-range locks support structure
|
|
FsRtlInitializeFileLock(&(PtrNewFcb->NTRequiredFCB->FileLock),NULL,NULL);
|
|
// Init reference counter
|
|
PtrNewFcb->NTRequiredFCB->CommonRefCount = 0;
|
|
Linked = FALSE;
|
|
} else {
|
|
ASSERT(PtrNewFcb->NTRequiredFCB->CommonFCBHeader.NodeTypeCode == UDF_NODE_TYPE_NT_REQ_FCB);
|
|
}
|
|
if(!NT_SUCCESS(status = UDFInitializeResourceLite(&(PtrNewFcb->CcbListResource)))) {
|
|
AdPrint((" Can't init resource (3)\n"));
|
|
BrutePoint();
|
|
if(!Linked) {
|
|
UDFDeleteResource(&(PtrNewFcb->NTRequiredFCB->PagingIoResource));
|
|
UDFDeleteResource(&(PtrNewFcb->NTRequiredFCB->MainResource));
|
|
PtrNewFcb->NTRequiredFCB->CommonFCBHeader.Resource =
|
|
PtrNewFcb->NTRequiredFCB->CommonFCBHeader.PagingIoResource = NULL;
|
|
FsRtlUninitializeFileLock(&(PtrNewFcb->NTRequiredFCB->FileLock));
|
|
}
|
|
return status;
|
|
}
|
|
|
|
// caller MUST ensure that VCB has been acquired exclusively
|
|
InsertTailList(&(Vcb->NextFCB), &(PtrNewFcb->NextFCB));
|
|
|
|
// initialize the various list heads
|
|
InitializeListHead(&(PtrNewFcb->NextCCB));
|
|
|
|
PtrNewFcb->ReferenceCount = 0;
|
|
PtrNewFcb->OpenHandleCount = 0;
|
|
|
|
PtrNewFcb->FCBFlags = Flags | UDF_FCB_INITIALIZED_CCB_LIST_RESOURCE;
|
|
|
|
PtrNewFcb->FCBName = PtrObjectName;
|
|
|
|
PtrNewFcb->Vcb = Vcb;
|
|
|
|
return STATUS_SUCCESS;
|
|
} // end UDFInitializeFCB()
|
|
|