mirror of
https://github.com/reactos/reactos.git
synced 2024-08-26 13:18:51 +00:00
2704 lines
106 KiB
C++
2704 lines
106 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: Fileinfo.cpp
|
|
*
|
|
* Module: UDF File System Driver (Kernel mode execution only)
|
|
*
|
|
* Description:
|
|
* Contains code to handle the "set/query file information" dispatch
|
|
* entry points.
|
|
*
|
|
*************************************************************************/
|
|
|
|
#include "udffs.h"
|
|
|
|
// define the file specific bug-check id
|
|
#define UDF_BUG_CHECK_ID UDF_FILE_INFORMATION
|
|
|
|
#define MEM_USREN_TAG "US_Ren"
|
|
#define MEM_USREN2_TAG "US_Ren2"
|
|
#define MEM_USFIDC_TAG "US_FIDC"
|
|
#define MEM_USHL_TAG "US_HL"
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFFileInfo()
|
|
*
|
|
* Description:
|
|
* The I/O Manager will invoke this routine to handle a set/query file
|
|
* information 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
|
|
UDFFileInfo(
|
|
PDEVICE_OBJECT DeviceObject, // the logical volume device object
|
|
PIRP Irp // I/O Request Packet
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PtrUDFIrpContext PtrIrpContext = NULL;
|
|
BOOLEAN AreWeTopLevel = FALSE;
|
|
|
|
TmPrint(("UDFFileInfo: \n"));
|
|
|
|
FsRtlEnterFileSystem();
|
|
ASSERT(DeviceObject);
|
|
ASSERT(Irp);
|
|
|
|
// set the top level context
|
|
AreWeTopLevel = UDFIsIrpTopLevel(Irp);
|
|
ASSERT(!UDFIsFSDevObj(DeviceObject));
|
|
|
|
_SEH2_TRY {
|
|
|
|
// get an IRP context structure and issue the request
|
|
PtrIrpContext = UDFAllocateIrpContext(Irp, DeviceObject);
|
|
if(PtrIrpContext) {
|
|
RC = UDFCommonFileInfo(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);
|
|
}
|
|
|
|
FsRtlExitFileSystem();
|
|
|
|
return(RC);
|
|
} // end UDFFileInfo()
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFCommonFileInfo()
|
|
*
|
|
* 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
|
|
UDFCommonFileInfo(
|
|
PtrUDFIrpContext PtrIrpContext,
|
|
PIRP Irp
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PIO_STACK_LOCATION IrpSp = NULL;
|
|
PFILE_OBJECT FileObject = NULL;
|
|
PtrUDFFCB Fcb = NULL;
|
|
PtrUDFCCB Ccb = NULL;
|
|
PVCB Vcb = NULL;
|
|
PtrUDFNTRequiredFCB NtReqFcb = NULL;
|
|
BOOLEAN MainResourceAcquired = FALSE;
|
|
BOOLEAN ParentResourceAcquired = FALSE;
|
|
BOOLEAN PagingIoResourceAcquired = FALSE;
|
|
PVOID PtrSystemBuffer = NULL;
|
|
LONG BufferLength = 0;
|
|
FILE_INFORMATION_CLASS FunctionalityRequested;
|
|
BOOLEAN CanWait = FALSE;
|
|
BOOLEAN PostRequest = FALSE;
|
|
BOOLEAN AcquiredVcb = FALSE;
|
|
PIRP TopIrp;
|
|
|
|
TmPrint(("UDFCommonFileInfo: irp %x\n", Irp));
|
|
|
|
TopIrp = IoGetTopLevelIrp();
|
|
switch((ULONG_PTR)TopIrp) {
|
|
case FSRTL_FSP_TOP_LEVEL_IRP:
|
|
UDFPrint((" FSRTL_FSP_TOP_LEVEL_IRP\n"));
|
|
break;
|
|
case FSRTL_CACHE_TOP_LEVEL_IRP:
|
|
UDFPrint((" FSRTL_CACHE_TOP_LEVEL_IRP\n"));
|
|
break;
|
|
case FSRTL_MOD_WRITE_TOP_LEVEL_IRP:
|
|
UDFPrint((" FSRTL_MOD_WRITE_TOP_LEVEL_IRP\n"));
|
|
break;
|
|
case FSRTL_FAST_IO_TOP_LEVEL_IRP:
|
|
UDFPrint((" FSRTL_FAST_IO_TOP_LEVEL_IRP\n"));
|
|
BrutePoint()
|
|
break;
|
|
case NULL:
|
|
UDFPrint((" NULL TOP_LEVEL_IRP\n"));
|
|
break;
|
|
default:
|
|
if(TopIrp == Irp) {
|
|
UDFPrint((" TOP_LEVEL_IRP\n"));
|
|
} else {
|
|
UDFPrint((" RECURSIVE_IRP, TOP = %x\n", TopIrp));
|
|
}
|
|
}
|
|
|
|
_SEH2_TRY {
|
|
// First, get a pointer to the current I/O stack location.
|
|
IrpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
ASSERT(IrpSp);
|
|
|
|
FileObject = IrpSp->FileObject;
|
|
ASSERT(FileObject);
|
|
|
|
// Get the FCB and CCB pointers.
|
|
Ccb = (PtrUDFCCB)(FileObject->FsContext2);
|
|
ASSERT(Ccb);
|
|
if(!Ccb) {
|
|
// some applications sends us FO without Ccb
|
|
// This is not allowed...
|
|
RC = STATUS_INVALID_PARAMETER;
|
|
try_return(RC);
|
|
}
|
|
Fcb = Ccb->Fcb;
|
|
ASSERT(Fcb);
|
|
|
|
NtReqFcb = Fcb->NTRequiredFCB;
|
|
|
|
CanWait = (PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_CAN_BLOCK) ? TRUE : FALSE;
|
|
|
|
// If the caller has opened a logical volume and is attempting to
|
|
// query information for it as a file stream, return an error.
|
|
if(Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB) {
|
|
// This is not allowed. Caller must use get/set volume information instead.
|
|
RC = STATUS_INVALID_PARAMETER;
|
|
try_return(RC);
|
|
}
|
|
|
|
|
|
Vcb = (PVCB)(IrpSp->DeviceObject->DeviceExtension);
|
|
ASSERT(Vcb);
|
|
ASSERT(Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_FCB);
|
|
//Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
|
|
|
|
// The NT I/O Manager always allocates and supplies a system
|
|
// buffer for query and set file information calls.
|
|
// Copying information to/from the user buffer and the system
|
|
// buffer is performed by the I/O Manager and the FSD need not worry about it.
|
|
PtrSystemBuffer = Irp->AssociatedIrp.SystemBuffer;
|
|
|
|
UDFFlushTryBreak(Vcb);
|
|
if(!UDFAcquireResourceShared(&(Vcb->VCBResource), CanWait)) {
|
|
PostRequest = TRUE;
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
AcquiredVcb = TRUE;
|
|
|
|
if(IrpSp->MajorFunction == IRP_MJ_QUERY_INFORMATION) {
|
|
// Now, obtain some parameters.
|
|
BufferLength = IrpSp->Parameters.QueryFile.Length;
|
|
FunctionalityRequested = IrpSp->Parameters.QueryFile.FileInformationClass;
|
|
#ifdef UDF_ENABLE_SECURITY
|
|
RC = IoCheckFunctionAccess(
|
|
Ccb->PreviouslyGrantedAccess,
|
|
PtrIrpContext->MajorFunction,
|
|
PtrIrpContext->MinorFunction,
|
|
0,
|
|
&FunctionalityRequested,
|
|
NULL);
|
|
if(!NT_SUCCESS(RC)) {
|
|
try_return(RC);
|
|
}
|
|
#endif //UDF_ENABLE_SECURITY
|
|
// Acquire the MainResource shared (NOTE: for paging-IO on a
|
|
// page file, we should avoid acquiring any resources and simply
|
|
// trust the VMM to do the right thing, else we could possibly
|
|
// run into deadlocks).
|
|
if(!(Fcb->FCBFlags & UDF_FCB_PAGE_FILE)) {
|
|
// Acquire the MainResource shared.
|
|
UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
|
|
UDFAcquireResourceShared(&(NtReqFcb->MainResource), TRUE);
|
|
MainResourceAcquired = TRUE;
|
|
}
|
|
|
|
// Do whatever the caller asked us to do
|
|
switch (FunctionalityRequested) {
|
|
case FileBasicInformation:
|
|
RC = UDFGetBasicInformation(FileObject, Fcb, (PFILE_BASIC_INFORMATION)PtrSystemBuffer, &BufferLength);
|
|
break;
|
|
case FileStandardInformation:
|
|
RC = UDFGetStandardInformation(Fcb, (PFILE_STANDARD_INFORMATION) PtrSystemBuffer, &BufferLength);
|
|
break;
|
|
#if(_WIN32_WINNT >= 0x0400)
|
|
case FileNetworkOpenInformation:
|
|
RC = UDFGetNetworkInformation(Fcb, (PFILE_NETWORK_OPEN_INFORMATION)PtrSystemBuffer, &BufferLength);
|
|
break;
|
|
#endif // _WIN32_WINNT >= 0x0400
|
|
case FileInternalInformation:
|
|
RC = UDFGetInternalInformation(PtrIrpContext, Fcb, Ccb, (PFILE_INTERNAL_INFORMATION) PtrSystemBuffer, &BufferLength);
|
|
break;
|
|
case FileEaInformation:
|
|
RC = UDFGetEaInformation(PtrIrpContext, Fcb, (PFILE_EA_INFORMATION) PtrSystemBuffer, &BufferLength);
|
|
break;
|
|
case FileNameInformation:
|
|
RC = UDFGetFullNameInformation(FileObject, (PFILE_NAME_INFORMATION) PtrSystemBuffer, &BufferLength);
|
|
break;
|
|
case FileAlternateNameInformation:
|
|
RC = UDFGetAltNameInformation(Fcb, (PFILE_NAME_INFORMATION) PtrSystemBuffer, &BufferLength);
|
|
break;
|
|
// case FileCompressionInformation:
|
|
// // RC = UDFGetCompressionInformation(...);
|
|
// break;
|
|
case FilePositionInformation:
|
|
RC = UDFGetPositionInformation(FileObject, (PFILE_POSITION_INFORMATION)PtrSystemBuffer, &BufferLength);
|
|
break;
|
|
case FileStreamInformation:
|
|
RC = UDFGetFileStreamInformation(Fcb, (PFILE_STREAM_INFORMATION) PtrSystemBuffer, &BufferLength);
|
|
break;
|
|
case FileAllInformation:
|
|
// The I/O Manager supplies the Mode, Access, and Alignment
|
|
// information. The rest is up to us to provide.
|
|
// Therefore, decrement the BufferLength appropriately (assuming
|
|
// that the above 3 types on information are already in the
|
|
// buffer)
|
|
{
|
|
PFILE_ALL_INFORMATION PtrAllInfo = (PFILE_ALL_INFORMATION)PtrSystemBuffer;
|
|
|
|
BufferLength -= (sizeof(FILE_MODE_INFORMATION) +
|
|
sizeof(FILE_ACCESS_INFORMATION) +
|
|
sizeof(FILE_ALIGNMENT_INFORMATION));
|
|
|
|
// Get the remaining stuff.
|
|
if(!NT_SUCCESS(RC = UDFGetBasicInformation(FileObject, Fcb, &(PtrAllInfo->BasicInformation), &BufferLength)) ||
|
|
!NT_SUCCESS(RC = UDFGetStandardInformation(Fcb, &(PtrAllInfo->StandardInformation), &BufferLength)) ||
|
|
!NT_SUCCESS(RC = UDFGetInternalInformation(PtrIrpContext, Fcb, Ccb, &(PtrAllInfo->InternalInformation), &BufferLength)) ||
|
|
!NT_SUCCESS(RC = UDFGetEaInformation(PtrIrpContext, Fcb, &(PtrAllInfo->EaInformation), &BufferLength)) ||
|
|
!NT_SUCCESS(RC = UDFGetPositionInformation(FileObject, &(PtrAllInfo->PositionInformation), &BufferLength)) ||
|
|
!NT_SUCCESS(RC = UDFGetFullNameInformation(FileObject, &(PtrAllInfo->NameInformation), &BufferLength))
|
|
)
|
|
try_return(RC);
|
|
}
|
|
break;
|
|
default:
|
|
RC = STATUS_INVALID_PARAMETER;
|
|
try_return(RC);
|
|
}
|
|
|
|
#ifndef UDF_READ_ONLY_BUILD
|
|
} else {
|
|
// if(IrpSp->MajorFunction == IRP_MJ_SET_INFORMATION) {
|
|
Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
|
|
ASSERT(IrpSp->MajorFunction == IRP_MJ_SET_INFORMATION);
|
|
// Now, obtain some parameters.
|
|
FunctionalityRequested = IrpSp->Parameters.SetFile.FileInformationClass;
|
|
if((Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY) &&
|
|
(FunctionalityRequested != FilePositionInformation)) {
|
|
try_return(RC = STATUS_ACCESS_DENIED);
|
|
}
|
|
#ifdef UDF_ENABLE_SECURITY
|
|
RC = IoCheckFunctionAccess(
|
|
Ccb->PreviouslyGrantedAccess,
|
|
PtrIrpContext->MajorFunction,
|
|
PtrIrpContext->MinorFunction,
|
|
0,
|
|
&FunctionalityRequested,
|
|
NULL);
|
|
if(!NT_SUCCESS(RC)) {
|
|
try_return(RC);
|
|
}
|
|
#endif //UDF_ENABLE_SECURITY
|
|
// If the FSD supports opportunistic locking,
|
|
// then we should check whether the oplock state
|
|
// allows the caller to proceed.
|
|
|
|
// Rename, and link operations require creation of a directory
|
|
// entry and possibly deletion of another directory entry.
|
|
|
|
// Unless this is an operation on a page file, we should go ahead and
|
|
// acquire the FCB exclusively at this time. Note that we will pretty
|
|
// much block out anything being done to the FCB from this point on.
|
|
if(!(Fcb->FCBFlags & UDF_FCB_PAGE_FILE) &&
|
|
(FunctionalityRequested != FilePositionInformation) &&
|
|
(FunctionalityRequested != FileRenameInformation) &&
|
|
(FunctionalityRequested != FileLinkInformation)) {
|
|
// Acquire the Parent & Main Resources exclusive.
|
|
if(Fcb->FileInfo->ParentFile) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(Fcb->ParentFcb->NTRequiredFCB);
|
|
if(!UDFAcquireResourceExclusive(&(Fcb->ParentFcb->NTRequiredFCB->MainResource), CanWait)) {
|
|
PostRequest = TRUE;
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
ParentResourceAcquired = TRUE;
|
|
}
|
|
UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
|
|
if(!UDFAcquireResourceExclusive(&(NtReqFcb->MainResource), CanWait)) {
|
|
PostRequest = TRUE;
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
MainResourceAcquired = TRUE;
|
|
} else
|
|
// The only operations that could conceivably proceed from this point
|
|
// on are paging-IO read/write operations. For delete, link (rename),
|
|
// set allocation size, and set EOF, should also acquire the paging-IO
|
|
// resource, thereby synchronizing with paging-IO requests.
|
|
if((Fcb->FCBFlags & UDF_FCB_PAGE_FILE) &&
|
|
((FunctionalityRequested == FileDispositionInformation) ||
|
|
(FunctionalityRequested == FileAllocationInformation) ||
|
|
(FunctionalityRequested == FileEndOfFileInformation)) ) {
|
|
|
|
// Acquire the MainResource shared.
|
|
UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
|
|
if(!UDFAcquireResourceShared(&(NtReqFcb->MainResource), CanWait)) {
|
|
PostRequest = TRUE;
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
MainResourceAcquired = TRUE;
|
|
// Acquire the PagingResource exclusive.
|
|
if(!UDFAcquireResourceExclusive(&(NtReqFcb->PagingIoResource), CanWait)) {
|
|
PostRequest = TRUE;
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
PagingIoResourceAcquired = TRUE;
|
|
} else if((FunctionalityRequested != FileRenameInformation) &&
|
|
(FunctionalityRequested != FileLinkInformation)) {
|
|
// Acquire the MainResource shared.
|
|
UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
|
|
if(!UDFAcquireResourceShared(&(NtReqFcb->MainResource), CanWait)) {
|
|
PostRequest = TRUE;
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
MainResourceAcquired = TRUE;
|
|
}
|
|
|
|
if((Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK) &&
|
|
(FunctionalityRequested != FilePositionInformation)) {
|
|
AdPrint((" Can't change File Information on blank volume ;)\n"));
|
|
try_return(RC = STATUS_ACCESS_DENIED);
|
|
}
|
|
|
|
// Do whatever the caller asked us to do
|
|
switch (FunctionalityRequested) {
|
|
case FileBasicInformation:
|
|
RC = UDFSetBasicInformation(Fcb, Ccb, FileObject, (PFILE_BASIC_INFORMATION)PtrSystemBuffer);
|
|
break;
|
|
case FilePositionInformation: {
|
|
// Check if no intermediate buffering has been specified.
|
|
// If it was specified, do not allow non-aligned set file
|
|
// position requests to succeed.
|
|
PFILE_POSITION_INFORMATION PtrFileInfoBuffer;
|
|
|
|
PtrFileInfoBuffer = (PFILE_POSITION_INFORMATION)PtrSystemBuffer;
|
|
|
|
if(FileObject->Flags & FO_NO_INTERMEDIATE_BUFFERING) {
|
|
if(PtrFileInfoBuffer->CurrentByteOffset.LowPart & IrpSp->DeviceObject->AlignmentRequirement) {
|
|
// Invalid alignment.
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
}
|
|
}
|
|
|
|
FileObject->CurrentByteOffset = PtrFileInfoBuffer->CurrentByteOffset;
|
|
break;
|
|
}
|
|
case FileDispositionInformation:
|
|
RC = UDFSetDispositionInformation(Fcb, Ccb, Vcb, FileObject,
|
|
((PFILE_DISPOSITION_INFORMATION)PtrSystemBuffer)->DeleteFile ? TRUE : FALSE);
|
|
break;
|
|
case FileRenameInformation:
|
|
if(!CanWait) {
|
|
PostRequest = TRUE;
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
RC = UDFRename(IrpSp, Fcb, Ccb, FileObject, (PFILE_RENAME_INFORMATION)PtrSystemBuffer);
|
|
if(RC == STATUS_PENDING) {
|
|
PostRequest = TRUE;
|
|
try_return(RC);
|
|
}
|
|
break;
|
|
#ifdef UDF_ALLOW_HARD_LINKS
|
|
case FileLinkInformation:
|
|
if(!CanWait) {
|
|
PostRequest = TRUE;
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
RC = UDFHardLink(IrpSp, Fcb, Ccb, FileObject, (PFILE_LINK_INFORMATION)PtrSystemBuffer);
|
|
break;
|
|
#endif //UDF_ALLOW_HARD_LINKS
|
|
case FileAllocationInformation:
|
|
RC = UDFSetAllocationInformation(Fcb, Ccb, Vcb, FileObject,
|
|
PtrIrpContext, Irp,
|
|
(PFILE_ALLOCATION_INFORMATION)PtrSystemBuffer);
|
|
break;
|
|
case FileEndOfFileInformation:
|
|
RC = UDFSetEOF(IrpSp, Fcb, Ccb, Vcb, FileObject, Irp, (PFILE_END_OF_FILE_INFORMATION)PtrSystemBuffer);
|
|
break;
|
|
default:
|
|
RC = STATUS_INVALID_PARAMETER;
|
|
try_return(RC);
|
|
}
|
|
#endif //UDF_READ_ONLY_BUILD
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
|
|
if(PagingIoResourceAcquired) {
|
|
UDFReleaseResource(&(NtReqFcb->PagingIoResource));
|
|
PagingIoResourceAcquired = FALSE;
|
|
}
|
|
|
|
if(MainResourceAcquired) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
|
|
UDFReleaseResource(&(NtReqFcb->MainResource));
|
|
MainResourceAcquired = FALSE;
|
|
}
|
|
|
|
if(ParentResourceAcquired) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(Fcb->ParentFcb->NTRequiredFCB);
|
|
UDFReleaseResource(&(Fcb->ParentFcb->NTRequiredFCB->MainResource));
|
|
ParentResourceAcquired = FALSE;
|
|
}
|
|
|
|
// Post IRP if required
|
|
if(PostRequest) {
|
|
|
|
// Since, the I/O Manager gave us a system buffer, we do not
|
|
// need to "lock" anything.
|
|
|
|
// Perform the post operation which will mark the IRP pending
|
|
// and will return STATUS_PENDING back to us
|
|
RC = UDFPostRequest(PtrIrpContext, Irp);
|
|
|
|
} else {
|
|
|
|
if (!_SEH2_AbnormalTermination()) {
|
|
Irp->IoStatus.Status = RC;
|
|
// Set status for "query" requests
|
|
if(IrpSp->MajorFunction == IRP_MJ_QUERY_INFORMATION) {
|
|
// Return the amount of information transferred.
|
|
Irp->IoStatus.Information = IrpSp->Parameters.QueryFile.Length - BufferLength;
|
|
#ifndef UDF_READ_ONLY_BUILD
|
|
#ifdef UDF_DELAYED_CLOSE
|
|
} else
|
|
if(NT_SUCCESS(RC)) {
|
|
if(FunctionalityRequested == FileDispositionInformation) {
|
|
if(AcquiredVcb) {
|
|
AcquiredVcb = FALSE;
|
|
UDFReleaseResource(&(Vcb->VCBResource));
|
|
}
|
|
UDFRemoveFromDelayedQueue(Fcb);
|
|
}
|
|
#endif //UDF_DELAYED_CLOSE
|
|
#endif //UDF_READ_ONLY_BUILD
|
|
}
|
|
// complete the IRP
|
|
IoCompleteRequest(Irp, IO_DISK_INCREMENT);
|
|
// Free up the Irp Context
|
|
UDFReleaseIrpContext(PtrIrpContext);
|
|
} // can we complete the IRP ?
|
|
|
|
}
|
|
if(AcquiredVcb) {
|
|
UDFReleaseResource(&(Vcb->VCBResource));
|
|
}
|
|
} _SEH2_END;// end of "__finally" processing
|
|
|
|
return(RC);
|
|
} // end UDFCommonFileInfo()
|
|
|
|
/*
|
|
Return some time-stamps and file attributes to the caller.
|
|
*/
|
|
NTSTATUS
|
|
UDFGetBasicInformation(
|
|
IN PFILE_OBJECT FileObject,
|
|
IN PtrUDFFCB Fcb,
|
|
IN PFILE_BASIC_INFORMATION PtrBuffer,
|
|
IN OUT LONG* PtrReturnedLength
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PUDF_FILE_INFO FileInfo;
|
|
PDIR_INDEX_ITEM DirNdx;
|
|
|
|
AdPrint(("UDFGetBasicInformation: \n"));
|
|
|
|
_SEH2_TRY {
|
|
|
|
if(*PtrReturnedLength < (LONG)sizeof(FILE_BASIC_INFORMATION)) {
|
|
try_return(RC = STATUS_BUFFER_OVERFLOW);
|
|
}
|
|
|
|
// Zero out the supplied buffer.
|
|
RtlZeroMemory(PtrBuffer, sizeof(FILE_BASIC_INFORMATION));
|
|
|
|
// Get information from the FCB and update TimesCache in DirIndex
|
|
FileInfo = Fcb->FileInfo;
|
|
|
|
if(!FileInfo) {
|
|
AdPrint(("!!!!!!!! Bu-u-u-u-u-g !!!!!!!!!!!\n"));
|
|
AdPrint(("!!!! GetBasicInfo to unopened file !!!!\n"));
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
}
|
|
|
|
DirNdx = UDFDirIndex(UDFGetDirIndexByFileInfo(FileInfo), FileInfo->Index);
|
|
|
|
PtrBuffer->CreationTime = Fcb->NTRequiredFCB->CreationTime;
|
|
DirNdx->CreationTime = PtrBuffer->CreationTime.QuadPart;
|
|
|
|
PtrBuffer->LastAccessTime = Fcb->NTRequiredFCB->LastAccessTime;
|
|
DirNdx->LastAccessTime = PtrBuffer->LastAccessTime.QuadPart;
|
|
|
|
PtrBuffer->LastWriteTime = Fcb->NTRequiredFCB->LastWriteTime;
|
|
DirNdx->LastWriteTime = PtrBuffer->LastWriteTime.QuadPart;
|
|
|
|
PtrBuffer->ChangeTime = Fcb->NTRequiredFCB->ChangeTime;
|
|
DirNdx->ChangeTime = PtrBuffer->ChangeTime.QuadPart;
|
|
|
|
// Now fill in the attributes.
|
|
if(Fcb->FCBFlags & UDF_FCB_DIRECTORY) {
|
|
PtrBuffer->FileAttributes = FILE_ATTRIBUTE_DIRECTORY;
|
|
#ifdef UDF_DBG
|
|
if(!FileInfo->Dloc->DirIndex) AdPrint(("*****!!!!! Directory has no DirIndex !!!!!*****\n"));
|
|
#endif
|
|
}
|
|
// Similarly, fill in attributes indicating a hidden file, system
|
|
// file, compressed file, temporary file, etc. if the FSD supports
|
|
// such file attribute values.
|
|
PtrBuffer->FileAttributes |= UDFAttributesToNT(DirNdx,NULL);
|
|
if(FileObject->Flags & FO_TEMPORARY_FILE) {
|
|
PtrBuffer->FileAttributes |= FILE_ATTRIBUTE_TEMPORARY;
|
|
} else {
|
|
PtrBuffer->FileAttributes &= ~FILE_ATTRIBUTE_TEMPORARY;
|
|
}
|
|
if(!PtrBuffer->FileAttributes) {
|
|
PtrBuffer->FileAttributes = FILE_ATTRIBUTE_NORMAL;
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
|
|
if(NT_SUCCESS(RC)) {
|
|
// Return the amount of information filled in.
|
|
(*PtrReturnedLength) -= sizeof(FILE_BASIC_INFORMATION);
|
|
}
|
|
} _SEH2_END;
|
|
return(RC);
|
|
} // end UDFGetBasicInformation()
|
|
|
|
|
|
/*
|
|
Return file sizes to the caller.
|
|
*/
|
|
NTSTATUS
|
|
UDFGetStandardInformation(
|
|
IN PtrUDFFCB Fcb,
|
|
IN PFILE_STANDARD_INFORMATION PtrBuffer,
|
|
IN OUT LONG* PtrReturnedLength
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PUDF_FILE_INFO FileInfo;
|
|
// PVCB Vcb;
|
|
|
|
AdPrint(("UDFGetStandardInformation: \n"));
|
|
|
|
_SEH2_TRY {
|
|
|
|
if(*PtrReturnedLength < (LONG)sizeof(FILE_STANDARD_INFORMATION)) {
|
|
try_return(RC = STATUS_BUFFER_OVERFLOW);
|
|
}
|
|
|
|
// Zero out the supplied buffer.
|
|
RtlZeroMemory(PtrBuffer, sizeof(FILE_STANDARD_INFORMATION));
|
|
|
|
FileInfo = Fcb->FileInfo;
|
|
|
|
if(!FileInfo) {
|
|
AdPrint(("!!!!!!!! Bu-u-u-u-u-g !!!!!!!!!!!\n"));
|
|
AdPrint(("!!!! GetStandardInfo to unopened file !!!!\n"));
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
}
|
|
// Vcb = Fcb->Vcb;
|
|
PtrBuffer->NumberOfLinks = UDFGetFileLinkCount(FileInfo);
|
|
PtrBuffer->DeletePending = (Fcb->FCBFlags & UDF_FCB_DELETE_ON_CLOSE) ? TRUE : FALSE;
|
|
|
|
// Case on whether this is a file or a directory, and extract
|
|
// the information and fill in the fcb/dcb specific parts
|
|
// of the output buffer
|
|
if(UDFIsADirectory(Fcb->FileInfo)) {
|
|
PtrBuffer->Directory = TRUE;
|
|
} else {
|
|
if(Fcb->NTRequiredFCB->CommonFCBHeader.AllocationSize.LowPart == 0xffffffff) {
|
|
Fcb->NTRequiredFCB->CommonFCBHeader.AllocationSize.QuadPart =
|
|
UDFSysGetAllocSize(Fcb->Vcb, UDFGetFileSize(FileInfo));
|
|
}
|
|
PtrBuffer->AllocationSize = Fcb->NTRequiredFCB->CommonFCBHeader.AllocationSize;
|
|
PtrBuffer->EndOfFile = Fcb->NTRequiredFCB->CommonFCBHeader.FileSize;
|
|
|
|
PtrBuffer->Directory = FALSE;
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
} _SEH2_FINALLY {
|
|
if(NT_SUCCESS(RC)) {
|
|
// Return the amount of information filled in.
|
|
*PtrReturnedLength -= sizeof(FILE_STANDARD_INFORMATION);
|
|
}
|
|
} _SEH2_END;
|
|
return(RC);
|
|
} // end UDFGetStandardInformation()
|
|
|
|
/*
|
|
Return some time-stamps and file attributes to the caller.
|
|
*/
|
|
NTSTATUS
|
|
UDFGetNetworkInformation(
|
|
IN PtrUDFFCB Fcb,
|
|
IN PFILE_NETWORK_OPEN_INFORMATION PtrBuffer,
|
|
IN OUT PLONG PtrReturnedLength
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PUDF_FILE_INFO FileInfo;
|
|
|
|
AdPrint(("UDFGetNetworkInformation: \n"));
|
|
|
|
_SEH2_TRY {
|
|
|
|
if(*PtrReturnedLength < (LONG)sizeof(FILE_NETWORK_OPEN_INFORMATION)) {
|
|
try_return(RC = STATUS_BUFFER_OVERFLOW);
|
|
}
|
|
|
|
// Zero out the supplied buffer.
|
|
RtlZeroMemory(PtrBuffer, sizeof(FILE_NETWORK_OPEN_INFORMATION));
|
|
|
|
// Get information from the FCB.
|
|
PtrBuffer->CreationTime = Fcb->NTRequiredFCB->CreationTime;
|
|
PtrBuffer->LastAccessTime = Fcb->NTRequiredFCB->LastAccessTime;
|
|
PtrBuffer->LastWriteTime = Fcb->NTRequiredFCB->LastWriteTime;
|
|
PtrBuffer->ChangeTime = Fcb->NTRequiredFCB->ChangeTime;
|
|
|
|
FileInfo = Fcb->FileInfo;
|
|
|
|
if(!FileInfo) {
|
|
AdPrint(("!!!!!!!! Bu-u-u-u-u-g !!!!!!!!!!!\n"));
|
|
AdPrint(("!!!! UDFGetNetworkInformation to unopened file !!!!\n"));
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
}
|
|
// Now fill in the attributes.
|
|
if(Fcb->FCBFlags & UDF_FCB_DIRECTORY) {
|
|
PtrBuffer->FileAttributes = FILE_ATTRIBUTE_DIRECTORY;
|
|
#ifdef UDF_DBG
|
|
if(!FileInfo->Dloc->DirIndex) AdPrint(("*****!!!!! Directory has no DirIndex !!!!!*****\n"));
|
|
#endif
|
|
} else {
|
|
if(Fcb->NTRequiredFCB->CommonFCBHeader.AllocationSize.LowPart == 0xffffffff) {
|
|
Fcb->NTRequiredFCB->CommonFCBHeader.AllocationSize.QuadPart =
|
|
UDFSysGetAllocSize(Fcb->Vcb, UDFGetFileSize(FileInfo));
|
|
}
|
|
PtrBuffer->AllocationSize = Fcb->NTRequiredFCB->CommonFCBHeader.AllocationSize;
|
|
PtrBuffer->EndOfFile = Fcb->NTRequiredFCB->CommonFCBHeader.FileSize;
|
|
}
|
|
// Similarly, fill in attributes indicating a hidden file, system
|
|
// file, compressed file, temporary file, etc. if the FSD supports
|
|
// such file attribute values.
|
|
PtrBuffer->FileAttributes |= UDFAttributesToNT(UDFDirIndex(UDFGetDirIndexByFileInfo(FileInfo), FileInfo->Index),NULL);
|
|
if(!PtrBuffer->FileAttributes) {
|
|
PtrBuffer->FileAttributes = FILE_ATTRIBUTE_NORMAL;
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
if(NT_SUCCESS(RC)) {
|
|
// Return the amount of information filled in.
|
|
(*PtrReturnedLength) -= sizeof(FILE_NETWORK_OPEN_INFORMATION);
|
|
}
|
|
} _SEH2_END;
|
|
return(RC);
|
|
} // end UDFGetNetworkInformation()
|
|
|
|
|
|
/*
|
|
Return some time-stamps and file attributes to the caller.
|
|
*/
|
|
NTSTATUS
|
|
UDFGetInternalInformation(
|
|
PtrUDFIrpContext PtrIrpContext,
|
|
IN PtrUDFFCB Fcb,
|
|
IN PtrUDFCCB Ccb,
|
|
IN PFILE_INTERNAL_INFORMATION PtrBuffer,
|
|
IN OUT PLONG PtrReturnedLength
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PUDF_FILE_INFO FileInfo;
|
|
PVCB Vcb;
|
|
|
|
AdPrint(("UDFGetInternalInformation\n"));
|
|
|
|
_SEH2_TRY {
|
|
|
|
if(*PtrReturnedLength < (LONG)sizeof(FILE_INTERNAL_INFORMATION)) {
|
|
try_return(RC = STATUS_BUFFER_OVERFLOW);
|
|
}
|
|
|
|
// Zero out the supplied buffer.
|
|
RtlZeroMemory(PtrBuffer, sizeof(FILE_INTERNAL_INFORMATION));
|
|
|
|
FileInfo = Fcb->FileInfo;
|
|
|
|
if(!FileInfo) {
|
|
AdPrint(("!!!!!!!! Bu-u-u-u-u-g !!!!!!!!!!!\n"));
|
|
AdPrint(("!!!! UDFGetInternalInformation to unopened file !!!!\n"));
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
}
|
|
|
|
Vcb = Fcb->Vcb;
|
|
PtrBuffer->IndexNumber.QuadPart = UDFGetNTFileId(Vcb, FileInfo, &(Fcb->FCBName->ObjectName));
|
|
|
|
UDFAcquireResourceExclusive(&(Fcb->Vcb->FileIdResource), TRUE);
|
|
// remember File Id & full path
|
|
UDFStoreFileId(Fcb->Vcb, Ccb, FileInfo, PtrBuffer->IndexNumber.QuadPart);
|
|
UDFReleaseResource(&(Fcb->Vcb->FileIdResource));
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
if(NT_SUCCESS(RC)) {
|
|
// Return the amount of information filled in.
|
|
*PtrReturnedLength -= sizeof(FILE_INTERNAL_INFORMATION);
|
|
}
|
|
} _SEH2_END;
|
|
return(RC);
|
|
} // end UDFGetInternalInformation()
|
|
|
|
/*
|
|
Return zero-filled EAs to the caller.
|
|
*/
|
|
NTSTATUS
|
|
UDFGetEaInformation(
|
|
PtrUDFIrpContext PtrIrpContext,
|
|
IN PtrUDFFCB Fcb,
|
|
IN PFILE_EA_INFORMATION PtrBuffer,
|
|
IN OUT PLONG PtrReturnedLength
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
|
|
AdPrint(("UDFGetEaInformation\n"));
|
|
|
|
_SEH2_TRY {
|
|
|
|
if(*PtrReturnedLength < (LONG)sizeof(FILE_EA_INFORMATION)) {
|
|
try_return(RC = STATUS_BUFFER_OVERFLOW);
|
|
}
|
|
|
|
// Zero out the supplied buffer.
|
|
PtrBuffer->EaSize = 0;
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
if(NT_SUCCESS(RC)) {
|
|
// Return the amount of information filled in.
|
|
*PtrReturnedLength -= sizeof(FILE_EA_INFORMATION);
|
|
}
|
|
} _SEH2_END;
|
|
return(RC);
|
|
} // end UDFGetEaInformation()
|
|
|
|
/*
|
|
Return file's long name to the caller.
|
|
*/
|
|
NTSTATUS
|
|
UDFGetFullNameInformation(
|
|
IN PFILE_OBJECT FileObject,
|
|
IN PFILE_NAME_INFORMATION PtrBuffer,
|
|
IN OUT PLONG PtrReturnedLength
|
|
)
|
|
{
|
|
ULONG BytesToCopy;
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
|
|
|
|
AdPrint(("UDFGetFullNameInformation\n"));
|
|
|
|
PtrBuffer->FileNameLength = FileObject->FileName.Length;
|
|
BytesToCopy = FileObject->FileName.Length;
|
|
|
|
if (PtrBuffer->FileNameLength + sizeof( ULONG ) > (ULONG)(*PtrReturnedLength)) {
|
|
|
|
BytesToCopy = *PtrReturnedLength - sizeof( ULONG );
|
|
RC = STATUS_BUFFER_OVERFLOW;
|
|
}
|
|
|
|
RtlCopyMemory( PtrBuffer->FileName, FileObject->FileName.Buffer, BytesToCopy );
|
|
|
|
// Reduce the available bytes by the amount stored into this buffer.
|
|
*PtrReturnedLength -= sizeof( ULONG ) + PtrBuffer->FileNameLength;
|
|
|
|
return RC;
|
|
} // end UDFGetFullNameInformation()
|
|
|
|
/*
|
|
Return file short(8.3) name to the caller.
|
|
*/
|
|
NTSTATUS
|
|
UDFGetAltNameInformation(
|
|
IN PtrUDFFCB Fcb,
|
|
IN PFILE_NAME_INFORMATION PtrBuffer,
|
|
IN OUT PLONG PtrReturnedLength
|
|
)
|
|
{
|
|
PDIR_INDEX_ITEM DirNdx;
|
|
ULONG BytesToCopy;
|
|
UNICODE_STRING ShortName;
|
|
WCHAR ShortNameBuffer[13];
|
|
|
|
AdPrint(("UDFGetAltNameInformation: \n"));
|
|
|
|
*PtrReturnedLength -= FIELD_OFFSET(FILE_NAME_INFORMATION, FileName[0]);
|
|
DirNdx = UDFDirIndex(UDFGetDirIndexByFileInfo(Fcb->FileInfo), Fcb->FileInfo->Index);
|
|
|
|
ShortName.MaximumLength = 13 * sizeof(WCHAR);
|
|
ShortName.Buffer = (PWCHAR)&ShortNameBuffer;
|
|
|
|
UDFDOSName__(Fcb->Vcb, &ShortName, &(DirNdx->FName), Fcb->FileInfo);
|
|
|
|
if(*PtrReturnedLength < ShortName.Length) {
|
|
return(STATUS_BUFFER_OVERFLOW);
|
|
} else {
|
|
BytesToCopy = ShortName.Length;
|
|
*PtrReturnedLength -= ShortName.Length;
|
|
}
|
|
|
|
RtlCopyMemory( &(PtrBuffer->FileName),
|
|
ShortName.Buffer,
|
|
BytesToCopy );
|
|
|
|
PtrBuffer->FileNameLength = ShortName.Length;
|
|
|
|
return(STATUS_SUCCESS);
|
|
} // end UDFGetAltNameInformation()
|
|
|
|
/*
|
|
Get file position information
|
|
*/
|
|
NTSTATUS
|
|
UDFGetPositionInformation(
|
|
IN PFILE_OBJECT FileObject,
|
|
IN PFILE_POSITION_INFORMATION PtrBuffer,
|
|
IN OUT PLONG PtrReturnedLength
|
|
)
|
|
{
|
|
if(*PtrReturnedLength < (LONG)sizeof(FILE_POSITION_INFORMATION)) {
|
|
return(STATUS_BUFFER_OVERFLOW);
|
|
}
|
|
PtrBuffer->CurrentByteOffset = FileObject->CurrentByteOffset;
|
|
// Modify the local variable for BufferLength appropriately.
|
|
*PtrReturnedLength -= sizeof(FILE_POSITION_INFORMATION);
|
|
|
|
return(STATUS_SUCCESS);
|
|
} // end UDFGetAltNameInformation()
|
|
|
|
/*
|
|
Get file file stream(s) information
|
|
*/
|
|
NTSTATUS
|
|
UDFGetFileStreamInformation(
|
|
IN PtrUDFFCB Fcb,
|
|
IN PFILE_STREAM_INFORMATION PtrBuffer,
|
|
IN OUT PLONG PtrReturnedLength
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PUDF_FILE_INFO FileInfo;
|
|
PUDF_FILE_INFO SDirInfo;
|
|
PVCB Vcb;
|
|
BOOLEAN FcbAcquired = FALSE;
|
|
uint_di i;
|
|
LONG l;
|
|
PDIR_INDEX_HDR hSDirIndex;
|
|
PDIR_INDEX_ITEM SDirIndex;
|
|
PFILE_BOTH_DIR_INFORMATION NTFileInfo = NULL;
|
|
|
|
AdPrint(("UDFGetFileStreamInformation\n"));
|
|
|
|
_SEH2_TRY {
|
|
|
|
UDFAcquireResourceExclusive(&(Fcb->Vcb->FileIdResource), TRUE);
|
|
FcbAcquired = TRUE;
|
|
|
|
FileInfo = Fcb->FileInfo;
|
|
if(!FileInfo) {
|
|
AdPrint(("!!!!!!!! Bu-u-u-u-u-g !!!!!!!!!!!\n"));
|
|
AdPrint(("!!!! UDFGetFileStreamInformation to unopened file !!!!\n"));
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
}
|
|
Vcb = Fcb->Vcb;
|
|
// Zero out the supplied buffer.
|
|
RtlZeroMemory(PtrBuffer, *PtrReturnedLength);
|
|
if(!(SDirInfo = FileInfo->Dloc->SDirInfo) ||
|
|
UDFIsSDirDeleted(SDirInfo) ) {
|
|
(*PtrReturnedLength) -= (sizeof(FILE_STREAM_INFORMATION) - sizeof(WCHAR));
|
|
try_return(RC = STATUS_SUCCESS);
|
|
}
|
|
|
|
hSDirIndex = SDirInfo->Dloc->DirIndex;
|
|
NTFileInfo = (PFILE_BOTH_DIR_INFORMATION)MyAllocatePool__(NonPagedPool, sizeof(FILE_BOTH_DIR_INFORMATION)+UDF_NAME_LEN*sizeof(WCHAR));
|
|
if(!NTFileInfo) try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
|
|
|
|
for(i=2; (SDirIndex = UDFDirIndex(hSDirIndex,i)); i++) {
|
|
if((SDirIndex->FI_Flags & UDF_FI_FLAG_FI_INTERNAL) ||
|
|
UDFIsDeleted(SDirIndex) ||
|
|
!SDirIndex->FName.Buffer )
|
|
continue;
|
|
// copy data to buffer
|
|
if(*PtrReturnedLength < (l = ((sizeof(FILE_STREAM_INFORMATION) - sizeof(WCHAR)) +
|
|
SDirIndex->FName.Length + 3) & (~3)) ) {
|
|
try_return(RC = STATUS_BUFFER_OVERFLOW);
|
|
}
|
|
RC = UDFFileDirInfoToNT(Vcb, SDirIndex, NTFileInfo);
|
|
|
|
PtrBuffer->NextEntryOffset = l;
|
|
PtrBuffer->StreamNameLength = SDirIndex->FName.Length;
|
|
PtrBuffer->StreamSize = NTFileInfo->EndOfFile;
|
|
PtrBuffer->StreamAllocationSize = NTFileInfo->AllocationSize;
|
|
RtlCopyMemory(&(PtrBuffer->StreamName), SDirIndex->FName.Buffer, SDirIndex->FName.Length);
|
|
*PtrReturnedLength -= l;
|
|
*((PCHAR*)(&PtrBuffer)) += l;
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
if(FcbAcquired)
|
|
UDFReleaseResource(&(Fcb->Vcb->FileIdResource));
|
|
if(NTFileInfo)
|
|
MyFreePool__(NTFileInfo);
|
|
} _SEH2_END;
|
|
return(RC);
|
|
} // end UDFGetFileStreamInformation()
|
|
|
|
//*******************************************************************
|
|
|
|
#ifndef UDF_READ_ONLY_BUILD
|
|
|
|
/*
|
|
Set some time-stamps and file attributes supplied by the caller.
|
|
*/
|
|
NTSTATUS
|
|
UDFSetBasicInformation(
|
|
IN PtrUDFFCB Fcb,
|
|
IN PtrUDFCCB Ccb,
|
|
IN PFILE_OBJECT FileObject,
|
|
IN PFILE_BASIC_INFORMATION PtrBuffer)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
ULONG NotifyFilter = 0;
|
|
|
|
AdPrint(("UDFSetBasicInformation\n"));
|
|
|
|
_SEH2_TRY {
|
|
|
|
// Obtain a pointer to the directory entry associated with
|
|
// the FCB being modifed. The directory entry is obviously
|
|
// part of the data associated with the parent directory that
|
|
// contains this particular file stream.
|
|
if(PtrBuffer->FileAttributes) {
|
|
UDFUpdateAttrTime(Fcb->Vcb, Fcb->FileInfo);
|
|
} else
|
|
if( UDFIsADirectory(Fcb->FileInfo) &&
|
|
!(Fcb->Vcb->CompatFlags & UDF_VCB_IC_UPDATE_UCHG_DIR_ACCESS_TIME) &&
|
|
((Fcb->FileInfo->Dloc->DataLoc.Modified ||
|
|
Fcb->FileInfo->Dloc->AllocLoc.Modified ||
|
|
(Fcb->FileInfo->Dloc->FE_Flags & UDF_FE_FLAG_FE_MODIFIED) ||
|
|
Fcb->FileInfo->Dloc->FELoc.Modified))
|
|
) {
|
|
// ignore Access Time Modification for unchanged Dir
|
|
if(!PtrBuffer->CreationTime.QuadPart &&
|
|
PtrBuffer->LastAccessTime.QuadPart &&
|
|
!PtrBuffer->ChangeTime.QuadPart &&
|
|
!PtrBuffer->LastWriteTime.QuadPart)
|
|
try_return(RC);
|
|
}
|
|
|
|
UDFSetFileXTime(Fcb->FileInfo,
|
|
&(PtrBuffer->CreationTime.QuadPart),
|
|
&(PtrBuffer->LastAccessTime.QuadPart),
|
|
&(PtrBuffer->ChangeTime.QuadPart),
|
|
&(PtrBuffer->LastWriteTime.QuadPart) );
|
|
|
|
if(PtrBuffer->CreationTime.QuadPart) {
|
|
// The interesting thing here is that the user has set certain time
|
|
// fields. However, before doing this, the user may have performed
|
|
// I/O which in turn would have caused FSD to mark the fact that
|
|
// write/access time should be modifed at cleanup.
|
|
// We'll mark the fact that such updates are no longer
|
|
// required since the user has explicitly specified the values he
|
|
// wishes to see associated with the file stream.
|
|
Fcb->NTRequiredFCB->CreationTime = PtrBuffer->CreationTime;
|
|
Ccb->CCBFlags |= UDF_CCB_CREATE_TIME_SET;
|
|
NotifyFilter |= FILE_NOTIFY_CHANGE_CREATION;
|
|
}
|
|
if(PtrBuffer->LastAccessTime.QuadPart) {
|
|
Fcb->NTRequiredFCB->LastAccessTime = PtrBuffer->LastAccessTime;
|
|
Ccb->CCBFlags |= UDF_CCB_ACCESS_TIME_SET;
|
|
NotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
|
|
}
|
|
if(PtrBuffer->ChangeTime.QuadPart) {
|
|
Fcb->NTRequiredFCB->ChangeTime = PtrBuffer->ChangeTime;
|
|
Ccb->CCBFlags |= UDF_CCB_MODIFY_TIME_SET;
|
|
}
|
|
if(PtrBuffer->LastWriteTime.QuadPart) {
|
|
Fcb->NTRequiredFCB->LastWriteTime = PtrBuffer->LastWriteTime;
|
|
Ccb->CCBFlags |= UDF_CCB_WRITE_TIME_SET;
|
|
NotifyFilter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
|
|
}
|
|
|
|
// Now come the attributes.
|
|
if(PtrBuffer->FileAttributes) {
|
|
// We have a non-zero attribute value.
|
|
// The presence of a particular attribute indicates that the
|
|
// user wishes to set the attribute value. The absence indicates
|
|
// the user wishes to clear the particular attribute.
|
|
|
|
// Our routine ignores unsupported flags
|
|
PtrBuffer->FileAttributes &= ~(FILE_ATTRIBUTE_NORMAL);
|
|
|
|
// Similarly, we should pick out other invalid flag values.
|
|
if( (PtrBuffer->FileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
|
|
!(Fcb->FCBFlags & UDF_FCB_DIRECTORY))
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
|
|
if(PtrBuffer->FileAttributes & FILE_ATTRIBUTE_TEMPORARY) {
|
|
if(Fcb->FCBFlags & UDF_FCB_DIRECTORY)
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
FileObject->Flags |= FO_TEMPORARY_FILE;
|
|
} else {
|
|
FileObject->Flags &= ~FO_TEMPORARY_FILE;
|
|
}
|
|
|
|
if(PtrBuffer->FileAttributes & FILE_ATTRIBUTE_READONLY) {
|
|
Fcb->FCBFlags |= UDF_FCB_READ_ONLY;
|
|
} else {
|
|
Fcb->FCBFlags &= ~UDF_FCB_READ_ONLY;
|
|
}
|
|
|
|
UDFAttributesToUDF(UDFDirIndex(UDFGetDirIndexByFileInfo(Fcb->FileInfo), Fcb->FileInfo->Index),
|
|
NULL, PtrBuffer->FileAttributes);
|
|
|
|
(UDFDirIndex(UDFGetDirIndexByFileInfo(Fcb->FileInfo), Fcb->FileInfo->Index))
|
|
->FI_Flags |= UDF_FI_FLAG_SYS_ATTR;
|
|
// If the FSD supports file compression, we may wish to
|
|
// note the user's preferences for compressing/not compressing
|
|
// the file at this time.
|
|
Ccb->CCBFlags |= UDF_CCB_ATTRIBUTES_SET;
|
|
NotifyFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
|
|
}
|
|
|
|
if(NotifyFilter) {
|
|
UDFNotifyFullReportChange( Fcb->Vcb, Fcb->FileInfo,
|
|
NotifyFilter, FILE_ACTION_MODIFIED);
|
|
UDFSetFileSizeInDirNdx(Fcb->Vcb, Fcb->FileInfo, NULL);
|
|
Fcb->FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
} _SEH2_FINALLY {
|
|
;
|
|
} _SEH2_END;
|
|
return(RC);
|
|
} // end UDFSetBasicInformation()
|
|
|
|
NTSTATUS
|
|
UDFMarkStreamsForDeletion(
|
|
IN PVCB Vcb,
|
|
IN PtrUDFFCB Fcb,
|
|
IN BOOLEAN ForDel
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PUDF_FILE_INFO SDirInfo = NULL;
|
|
PUDF_FILE_INFO FileInfo = NULL;
|
|
ULONG lc;
|
|
BOOLEAN SDirAcq = FALSE;
|
|
BOOLEAN StrAcq = FALSE;
|
|
uint_di d,i;
|
|
|
|
_SEH2_TRY {
|
|
|
|
// In some cases we needn't marking Streams for deleteion
|
|
// (Not opened or Don't exist)
|
|
if(UDFIsAStream(Fcb->FileInfo) ||
|
|
UDFIsAStreamDir(Fcb->FileInfo) ||
|
|
!UDFHasAStreamDir(Fcb->FileInfo) ||
|
|
!Fcb->FileInfo->Dloc->SDirInfo ||
|
|
UDFIsSDirDeleted(Fcb->FileInfo->Dloc->SDirInfo) ||
|
|
(UDFGetFileLinkCount(Fcb->FileInfo) > 1) )
|
|
try_return (RC /*=STATUS_SUCCESS*/);
|
|
|
|
// We shall mark Streams for deletion if there is no
|
|
// Links to the file. Otherwise we'll delete only the file.
|
|
// If we are asked to unmark Streams, we'll precess the whole Tree
|
|
RC = UDFOpenStreamDir__(Vcb, Fcb->FileInfo, &SDirInfo);
|
|
if(!NT_SUCCESS(RC))
|
|
try_return(RC);
|
|
|
|
if(SDirInfo->Fcb &&
|
|
SDirInfo->Fcb->NTRequiredFCB) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(SDirInfo->Fcb->NTRequiredFCB);
|
|
UDFAcquireResourceExclusive(&(SDirInfo->Fcb->NTRequiredFCB->MainResource),TRUE);
|
|
SDirAcq = TRUE;
|
|
}
|
|
|
|
if(!ForDel || ((lc = UDFGetFileLinkCount(Fcb->FileInfo)) < 2)) {
|
|
|
|
UDF_DIR_SCAN_CONTEXT ScanContext;
|
|
PDIR_INDEX_ITEM DirNdx;
|
|
|
|
// It is not worth checking whether the Stream can be deleted if
|
|
// Undelete requested
|
|
if(ForDel &&
|
|
// scan DirIndex
|
|
UDFDirIndexInitScan(SDirInfo, &ScanContext, 2)) {
|
|
|
|
// Check if we can delete Streams
|
|
while((DirNdx = UDFDirIndexScan(&ScanContext, &FileInfo))) {
|
|
if(!FileInfo)
|
|
continue;
|
|
if(FileInfo->Fcb) {
|
|
FileInfo->Fcb->NTRequiredFCB->AcqFlushCount++;
|
|
MmPrint((" MmFlushImageSection() for Stream\n"));
|
|
if(!MmFlushImageSection(&(FileInfo->Fcb->NTRequiredFCB->SectionObject), MmFlushForDelete)) {
|
|
FileInfo->Fcb->NTRequiredFCB->AcqFlushCount--;
|
|
try_return(RC = STATUS_CANNOT_DELETE);
|
|
}
|
|
FileInfo->Fcb->NTRequiredFCB->AcqFlushCount--;
|
|
}
|
|
}
|
|
}
|
|
// (Un)Mark Streams for deletion
|
|
|
|
// Perform sequencial Open for Streams & mark 'em
|
|
// for deletion. We should not get FileInfo pointers directly
|
|
// from DirNdx[i] to prevent great troubles with linked
|
|
// files. We should mark for deletion FI with proper ParentFile
|
|
// pointer.
|
|
d = UDFDirIndexGetLastIndex(SDirInfo->Dloc->DirIndex);
|
|
for(i=2; i<d; i++) {
|
|
RC = UDFOpenFile__(Vcb,
|
|
FALSE,TRUE,NULL,
|
|
SDirInfo,&FileInfo,&i);
|
|
ASSERT(NT_SUCCESS(RC) || (RC == STATUS_FILE_DELETED));
|
|
if(NT_SUCCESS(RC)) {
|
|
if(FileInfo->Fcb) {
|
|
if(FileInfo->Fcb->NTRequiredFCB) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(FileInfo->Fcb->NTRequiredFCB);
|
|
UDFAcquireResourceExclusive(&(FileInfo->Fcb->NTRequiredFCB->MainResource),TRUE);
|
|
StrAcq = TRUE;
|
|
}
|
|
#ifndef UDF_ALLOW_LINKS_TO_STREAMS
|
|
if(UDFGetFileLinkCount(FileInfo) >= 2) {
|
|
// Currently, UDF_INFO package doesn't
|
|
// support this case, so we'll inform developer
|
|
// about this to prevent on-disk space leaks...
|
|
BrutePoint();
|
|
try_return(RC = STATUS_CANNOT_DELETE);
|
|
}
|
|
#endif //UDF_ALLOW_LINKS_TO_STREAMS
|
|
if(ForDel) {
|
|
AdPrint((" SET stream DeleteOnClose\n"));
|
|
#ifdef UDF_DBG
|
|
ASSERT(!(FileInfo->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY));
|
|
if(FileInfo->ParentFile &&
|
|
FileInfo->ParentFile->Fcb) {
|
|
ASSERT(!(FileInfo->ParentFile->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY));
|
|
}
|
|
#endif // UDF_DBG
|
|
FileInfo->Fcb->FCBFlags |= (UDF_FCB_DELETE_ON_CLOSE |
|
|
UDF_FCB_DELETE_PARENT);
|
|
} else {
|
|
AdPrint((" CLEAR stream DeleteOnClose\n"));
|
|
FileInfo->Fcb->FCBFlags &= ~(UDF_FCB_DELETE_ON_CLOSE |
|
|
UDF_FCB_DELETE_PARENT);
|
|
}
|
|
}
|
|
UDFCloseFile__(Vcb, FileInfo);
|
|
} else
|
|
if(RC == STATUS_FILE_DELETED) {
|
|
// That's OK if STATUS_FILE_DELETED returned...
|
|
RC = STATUS_SUCCESS;
|
|
}
|
|
if(FileInfo) {
|
|
if(UDFCleanUpFile__(Vcb, FileInfo)) {
|
|
ASSERT(!StrAcq && !(FileInfo->Fcb));
|
|
MyFreePool__(FileInfo);
|
|
}
|
|
if(StrAcq) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(FileInfo->Fcb->NTRequiredFCB);
|
|
UDFReleaseResource(&(FileInfo->Fcb->NTRequiredFCB->MainResource));
|
|
StrAcq = FALSE;
|
|
}
|
|
}
|
|
FileInfo = NULL;
|
|
}
|
|
// Mark SDir for deletion
|
|
if(SDirInfo->Fcb) {
|
|
if(ForDel) {
|
|
#ifdef UDF_DBG
|
|
ASSERT(!(SDirInfo->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY));
|
|
if(SDirInfo->ParentFile &&
|
|
SDirInfo->ParentFile->Fcb) {
|
|
ASSERT(!(SDirInfo->ParentFile->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY));
|
|
}
|
|
#endif // UDF_DBG
|
|
AdPrint((" SET stream dir DeleteOnClose\n"));
|
|
SDirInfo->Fcb->FCBFlags |= (UDF_FCB_DELETE_ON_CLOSE |
|
|
UDF_FCB_DELETE_PARENT);
|
|
} else {
|
|
AdPrint((" CLEAR stream dir DeleteOnClose\n"));
|
|
SDirInfo->Fcb->FCBFlags &= ~(UDF_FCB_DELETE_ON_CLOSE |
|
|
UDF_FCB_DELETE_PARENT);
|
|
}
|
|
}
|
|
} else
|
|
if(lc >= 2) {
|
|
// if caller wants us to perform DelTree for Streams, but
|
|
// someone keeps Stream opened and there is a Link to this
|
|
// file, we can't delete it immediately (on Cleanup) & should
|
|
// not delete the whole Tree. Instead, we'll set DELETE_PARENT
|
|
// flag in SDir to kill this file later, when all the Handles
|
|
// to Streams, opened via this file, would be closed
|
|
#ifdef UDF_DBG
|
|
ASSERT(!(SDirInfo->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY));
|
|
if(SDirInfo->ParentFile &&
|
|
SDirInfo->ParentFile->Fcb) {
|
|
ASSERT(!(SDirInfo->ParentFile->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY));
|
|
}
|
|
#endif // UDF_DBG
|
|
if(SDirInfo->Fcb)
|
|
SDirInfo->Fcb->FCBFlags |= UDF_FCB_DELETE_PARENT;
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
if(FileInfo) {
|
|
UDFCloseFile__(Vcb, FileInfo);
|
|
if(UDFCleanUpFile__(Vcb, FileInfo)) {
|
|
ASSERT(!StrAcq && !(FileInfo->Fcb));
|
|
MyFreePool__(FileInfo);
|
|
}
|
|
if(StrAcq) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(FileInfo->Fcb->NTRequiredFCB);
|
|
UDFReleaseResource(&(FileInfo->Fcb->NTRequiredFCB->MainResource));
|
|
}
|
|
SDirInfo = NULL;
|
|
}
|
|
if(SDirInfo) {
|
|
UDFCloseFile__(Vcb, SDirInfo);
|
|
if(SDirAcq) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(SDirInfo->Fcb->NTRequiredFCB);
|
|
UDFReleaseResource(&(SDirInfo->Fcb->NTRequiredFCB->MainResource));
|
|
}
|
|
if(UDFCleanUpFile__(Vcb, SDirInfo)) {
|
|
MyFreePool__(SDirInfo);
|
|
}
|
|
SDirInfo = NULL;
|
|
}
|
|
} _SEH2_END;
|
|
return RC;
|
|
} // end UDFMarkStreamsForDeletion()
|
|
|
|
/*
|
|
(Un)Mark file for deletion.
|
|
*/
|
|
NTSTATUS
|
|
UDFSetDispositionInformation(
|
|
IN PtrUDFFCB Fcb,
|
|
IN PtrUDFCCB Ccb,
|
|
IN PVCB Vcb,
|
|
IN PFILE_OBJECT FileObject,
|
|
IN BOOLEAN Delete
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
// PUDF_FILE_INFO SDirInfo = NULL;
|
|
// PUDF_FILE_INFO FileInfo = NULL;
|
|
ULONG lc;
|
|
|
|
AdPrint(("UDFSetDispositionInformation\n"));
|
|
|
|
_SEH2_TRY {
|
|
|
|
if(!Delete) {
|
|
AdPrint((" CLEAR DeleteOnClose\n"));
|
|
// "un-delete" the file.
|
|
Fcb->FCBFlags &= ~UDF_FCB_DELETE_ON_CLOSE;
|
|
if(FileObject)
|
|
FileObject->DeletePending = FALSE;
|
|
RC = UDFMarkStreamsForDeletion(Vcb, Fcb, FALSE); // Undelete
|
|
try_return(RC);
|
|
}
|
|
AdPrint((" SET DeleteOnClose\n"));
|
|
|
|
// The easy part is over. Now, we know that the user wishes to
|
|
// delete the corresponding directory entry (of course, if this
|
|
// is the only link to the file stream, any on-disk storage space
|
|
// associated with the file stream will also be released when the
|
|
// (only) link is deleted!)
|
|
|
|
// Do some checking to see if the file can even be deleted.
|
|
if(Fcb->FCBFlags & UDF_FCB_DELETE_ON_CLOSE) {
|
|
// All done!
|
|
try_return(RC);
|
|
}
|
|
|
|
if(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY) {
|
|
try_return(RC = STATUS_CANNOT_DELETE);
|
|
}
|
|
|
|
if(Fcb->FCBFlags & UDF_FCB_READ_ONLY) {
|
|
RC = UDFCheckAccessRights(NULL, NULL, Fcb->ParentFcb, NULL, FILE_DELETE_CHILD, 0);
|
|
if(!NT_SUCCESS(RC)) {
|
|
try_return (RC = STATUS_CANNOT_DELETE);
|
|
}
|
|
}
|
|
|
|
// It would not be prudent to allow deletion of either a root
|
|
// directory or a directory that is not empty.
|
|
if(Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY)
|
|
try_return(RC = STATUS_CANNOT_DELETE);
|
|
|
|
lc = UDFGetFileLinkCount(Fcb->FileInfo);
|
|
|
|
if(Fcb->FCBFlags & UDF_FCB_DIRECTORY) {
|
|
// Perform check to determine whether the directory
|
|
// is empty or not.
|
|
if(!UDFIsDirEmpty__(Fcb->FileInfo)) {
|
|
try_return(RC = STATUS_DIRECTORY_NOT_EMPTY);
|
|
}
|
|
|
|
} else {
|
|
// An important step is to check if the file stream has been
|
|
// mapped by any process. The delete cannot be allowed to proceed
|
|
// in this case.
|
|
MmPrint((" MmFlushImageSection()\n"));
|
|
Fcb->NTRequiredFCB->AcqFlushCount++;
|
|
if(!MmFlushImageSection(&(Fcb->NTRequiredFCB->SectionObject),
|
|
(lc > 1) ? MmFlushForWrite : MmFlushForDelete)) {
|
|
Fcb->NTRequiredFCB->AcqFlushCount--;
|
|
try_return(RC = STATUS_CANNOT_DELETE);
|
|
}
|
|
Fcb->NTRequiredFCB->AcqFlushCount--;
|
|
}
|
|
// We should also mark Streams for deletion if there are no
|
|
// Links to the file. Otherwise we'll delete only the file
|
|
|
|
if(lc > 1) {
|
|
RC = STATUS_SUCCESS;
|
|
} else {
|
|
RC = UDFMarkStreamsForDeletion(Vcb, Fcb, TRUE); // Delete
|
|
if(!NT_SUCCESS(RC))
|
|
try_return(RC);
|
|
}
|
|
|
|
// Set a flag to indicate that this directory entry will become history
|
|
// at cleanup.
|
|
Fcb->FCBFlags |= UDF_FCB_DELETE_ON_CLOSE;
|
|
if(FileObject)
|
|
FileObject->DeletePending = TRUE;
|
|
|
|
if((Fcb->FCBFlags & UDF_FCB_DIRECTORY) && Ccb) {
|
|
FsRtlNotifyFullChangeDirectory( Vcb->NotifyIRPMutex, &(Vcb->NextNotifyIRP),
|
|
(PVOID)Ccb, NULL, FALSE, FALSE,
|
|
0, NULL, NULL, NULL );
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
;
|
|
} _SEH2_END;
|
|
return(RC);
|
|
} // end UDFSetDispositionInformation()
|
|
|
|
|
|
/*
|
|
Change file allocation length.
|
|
*/
|
|
NTSTATUS
|
|
UDFSetAllocationInformation(
|
|
IN PtrUDFFCB Fcb,
|
|
IN PtrUDFCCB Ccb,
|
|
IN PVCB Vcb,
|
|
IN PFILE_OBJECT FileObject,
|
|
IN PtrUDFIrpContext PtrIrpContext,
|
|
IN PIRP Irp,
|
|
IN PFILE_ALLOCATION_INFORMATION PtrBuffer
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
BOOLEAN TruncatedFile = FALSE;
|
|
BOOLEAN ModifiedAllocSize = FALSE;
|
|
BOOLEAN CacheMapInitialized = FALSE;
|
|
BOOLEAN AcquiredPagingIo = FALSE;
|
|
|
|
AdPrint(("UDFSetAllocationInformation\n"));
|
|
|
|
_SEH2_TRY {
|
|
// Increasing the allocation size associated with a file stream
|
|
// is relatively easy. All we have to do is execute some FSD
|
|
// specific code to check whether we have enough space available
|
|
// (and if the FSD supports user/volume quotas, whether the user
|
|
// is not exceeding quota), and then increase the file size in the
|
|
// corresponding on-disk and in-memory structures.
|
|
// Then, all we should do is inform the Cache Manager about the
|
|
// increased allocation size.
|
|
|
|
// First, do whatever error checking is appropriate here (e.g. whether
|
|
// the caller is trying the change size for a directory, etc.).
|
|
if(Fcb->FCBFlags & UDF_FCB_DIRECTORY)
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
|
|
Fcb->NTRequiredFCB->CommonFCBHeader.IsFastIoPossible = UDFIsFastIoPossible(Fcb);
|
|
|
|
if ((FileObject->SectionObjectPointer->DataSectionObject != NULL) &&
|
|
(FileObject->SectionObjectPointer->SharedCacheMap == NULL) &&
|
|
!FlagOn(Irp->Flags, IRP_PAGING_IO)) {
|
|
ASSERT( !FlagOn( FileObject->Flags, FO_CLEANUP_COMPLETE ) );
|
|
// Now initialize the cache map.
|
|
MmPrint((" CcInitializeCacheMap()\n"));
|
|
CcInitializeCacheMap( FileObject,
|
|
(PCC_FILE_SIZES)&Fcb->NTRequiredFCB->CommonFCBHeader.AllocationSize,
|
|
FALSE,
|
|
&(UDFGlobalData.CacheMgrCallBacks),
|
|
Fcb->NTRequiredFCB );
|
|
|
|
CacheMapInitialized = TRUE;
|
|
}
|
|
|
|
// Are we increasing the allocation size?
|
|
if(Fcb->NTRequiredFCB->CommonFCBHeader.AllocationSize.QuadPart <
|
|
PtrBuffer->AllocationSize.QuadPart) {
|
|
|
|
// Yes. Do the FSD specific stuff i.e. increase reserved
|
|
// space on disk.
|
|
if(((LONGLONG)UDFGetFreeSpace(Vcb) << Vcb->LBlockSizeBits) < PtrBuffer->AllocationSize.QuadPart) {
|
|
try_return(RC = STATUS_DISK_FULL);
|
|
}
|
|
// RC = STATUS_SUCCESS;
|
|
ModifiedAllocSize = TRUE;
|
|
|
|
} else if(Fcb->NTRequiredFCB->CommonFCBHeader.AllocationSize.QuadPart >
|
|
PtrBuffer->AllocationSize.QuadPart) {
|
|
// This is the painful part. See if the VMM will allow us to proceed.
|
|
// The VMM will deny the request if:
|
|
// (a) any image section exists OR
|
|
// (b) a data section exists and the size of the user mapped view
|
|
// is greater than the new size
|
|
// Otherwise, the VMM should allow the request to proceed.
|
|
MmPrint((" MmCanFileBeTruncated()\n"));
|
|
if(!MmCanFileBeTruncated(&(Fcb->NTRequiredFCB->SectionObject), &(PtrBuffer->AllocationSize))) {
|
|
// VMM said no way!
|
|
try_return(RC = STATUS_USER_MAPPED_FILE);
|
|
}
|
|
|
|
// Perform our directory entry modifications. Release any on-disk
|
|
// space we may need to in the process.
|
|
ModifiedAllocSize = TRUE;
|
|
TruncatedFile = TRUE;
|
|
}
|
|
|
|
ASSERT(NT_SUCCESS(RC));
|
|
// This is a good place to check if we have performed a truncate
|
|
// operation. If we have perform a truncate (whether we extended
|
|
// or reduced file size or even leave it intact), we should update
|
|
// file time stamps.
|
|
FileObject->Flags |= FO_FILE_MODIFIED;
|
|
|
|
// Last, but not the lease, we must inform the Cache Manager of file size changes.
|
|
if(ModifiedAllocSize) {
|
|
|
|
// If we decreased the allocation size to less than the
|
|
// current file size, modify the file size value.
|
|
// Similarly, if we decreased the value to less than the
|
|
// current valid data length, modify that value as well.
|
|
|
|
AcquiredPagingIo = UDFAcquireResourceExclusiveWithCheck(&(Fcb->NTRequiredFCB->PagingIoResource));
|
|
// Update the FCB Header with the new allocation size.
|
|
if(TruncatedFile) {
|
|
if(Fcb->NTRequiredFCB->CommonFCBHeader.ValidDataLength.QuadPart >
|
|
PtrBuffer->AllocationSize.QuadPart) {
|
|
// Decrease the valid data length value.
|
|
Fcb->NTRequiredFCB->CommonFCBHeader.ValidDataLength =
|
|
PtrBuffer->AllocationSize;
|
|
}
|
|
if(Fcb->NTRequiredFCB->CommonFCBHeader.FileSize.QuadPart >
|
|
PtrBuffer->AllocationSize.QuadPart) {
|
|
// Decrease the file size value.
|
|
Fcb->NTRequiredFCB->CommonFCBHeader.FileSize =
|
|
PtrBuffer->AllocationSize;
|
|
RC = UDFResizeFile__(Vcb, Fcb->FileInfo, PtrBuffer->AllocationSize.QuadPart);
|
|
// UDFSetFileSizeInDirNdx(Vcb, Fcb->FileInfo, NULL);
|
|
}
|
|
} else {
|
|
Fcb->NTRequiredFCB->CommonFCBHeader.AllocationSize = PtrBuffer->AllocationSize;
|
|
// UDFSetFileSizeInDirNdx(Vcb, Fcb->FileInfo,
|
|
// &(PtrBuffer->AllocationSize.QuadPart));
|
|
}
|
|
if(AcquiredPagingIo) {
|
|
UDFReleaseResource(&(Fcb->NTRequiredFCB->PagingIoResource));
|
|
AcquiredPagingIo = FALSE;
|
|
}
|
|
// If the FCB has not had caching initiated, it is still valid
|
|
// for us to invoke the NT Cache Manager. It is possible in such
|
|
// situations for the call to be no'oped (unless some user has
|
|
// mapped in the file)
|
|
|
|
// NOTE: The invocation to CcSetFileSizes() will quite possibly
|
|
// result in a recursive call back into the file system.
|
|
// This is because the NT Cache Manager will typically
|
|
// perform a flush before telling the VMM to purge pages
|
|
// especially when caching has not been initiated on the
|
|
// file stream, but the user has mapped the file into
|
|
// the process' virtual address space.
|
|
MmPrint((" CcSetFileSizes()\n"));
|
|
Fcb->NTRequiredFCB->AcqFlushCount++;
|
|
CcSetFileSizes(FileObject, (PCC_FILE_SIZES)&(Fcb->NTRequiredFCB->CommonFCBHeader.AllocationSize));
|
|
Fcb->NTRequiredFCB->AcqFlushCount--;
|
|
Fcb->NTRequiredFCB->NtReqFCBFlags |= UDF_NTREQ_FCB_MODIFIED;
|
|
|
|
// Inform any pending IRPs (notify change directory).
|
|
if(UDFIsAStream(Fcb->FileInfo)) {
|
|
UDFNotifyFullReportChange( Vcb, Fcb->FileInfo,
|
|
FILE_NOTIFY_CHANGE_STREAM_SIZE,
|
|
FILE_ACTION_MODIFIED_STREAM);
|
|
} else {
|
|
UDFNotifyFullReportChange( Vcb, Fcb->FileInfo,
|
|
FILE_NOTIFY_CHANGE_SIZE,
|
|
FILE_ACTION_MODIFIED);
|
|
}
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
if(AcquiredPagingIo) {
|
|
UDFReleaseResource(&(Fcb->NTRequiredFCB->PagingIoResource));
|
|
AcquiredPagingIo = FALSE;
|
|
}
|
|
if (CacheMapInitialized) {
|
|
|
|
MmPrint((" CcUninitializeCacheMap()\n"));
|
|
CcUninitializeCacheMap( FileObject, NULL, NULL );
|
|
}
|
|
} _SEH2_END;
|
|
return(RC);
|
|
} // end UDFSetAllocationInformation()
|
|
|
|
/*
|
|
Set end of file (resize).
|
|
*/
|
|
NTSTATUS
|
|
UDFSetEOF(
|
|
IN PIO_STACK_LOCATION PtrSp,
|
|
IN PtrUDFFCB Fcb,
|
|
IN PtrUDFCCB Ccb,
|
|
IN PVCB Vcb,
|
|
IN PFILE_OBJECT FileObject,
|
|
IN PIRP Irp,
|
|
IN PFILE_END_OF_FILE_INFORMATION PtrBuffer
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
BOOLEAN TruncatedFile = FALSE;
|
|
BOOLEAN ModifiedAllocSize = FALSE;
|
|
ULONG Attr;
|
|
PDIR_INDEX_ITEM DirNdx;
|
|
PtrUDFNTRequiredFCB NtReqFcb = NULL;
|
|
LONGLONG OldFileSize;
|
|
// BOOLEAN ZeroBlock;
|
|
BOOLEAN CacheMapInitialized = FALSE;
|
|
BOOLEAN AcquiredPagingIo = FALSE;
|
|
|
|
AdPrint(("UDFSetEOF\n"));
|
|
|
|
_SEH2_TRY {
|
|
// Increasing the allocation size associated with a file stream
|
|
// is relatively easy. All we have to do is execute some FSD
|
|
// specific code to check whether we have enough space available
|
|
// (and if the FSD supports user/volume quotas, whether the user
|
|
// is not exceeding quota), and then increase the file size in the
|
|
// corresponding on-disk and in-memory structures.
|
|
// Then, all we should do is inform the Cache Manager about the
|
|
// increased allocation size.
|
|
|
|
// First, do whatever error checking is appropriate here (e.g. whether
|
|
// the caller is trying the change size for a directory, etc.).
|
|
if(Fcb->FCBFlags & UDF_FCB_DIRECTORY)
|
|
try_return(RC = STATUS_INVALID_PARAMETER);
|
|
|
|
NtReqFcb = Fcb->NTRequiredFCB;
|
|
|
|
if((Fcb->FCBFlags & UDF_FCB_DELETED) ||
|
|
(NtReqFcb->NtReqFCBFlags & UDF_NTREQ_FCB_DELETED)) {
|
|
#ifdef UDF_DBG
|
|
if(UDFGetFileLinkCount(Fcb->FileInfo) < 1) {
|
|
BrutePoint();
|
|
try_return(RC = STATUS_SUCCESS);
|
|
} else
|
|
#endif // UDF_DBG
|
|
try_return(RC = STATUS_SUCCESS);
|
|
}
|
|
|
|
NtReqFcb->CommonFCBHeader.IsFastIoPossible = UDFIsFastIoPossible(Fcb);
|
|
|
|
if ((FileObject->SectionObjectPointer->DataSectionObject != NULL) &&
|
|
(FileObject->SectionObjectPointer->SharedCacheMap == NULL) &&
|
|
!(Irp->Flags & IRP_PAGING_IO)) {
|
|
ASSERT( !FlagOn( FileObject->Flags, FO_CLEANUP_COMPLETE ) );
|
|
// Now initialize the cache map.
|
|
MmPrint((" CcInitializeCacheMap()\n"));
|
|
CcInitializeCacheMap( FileObject,
|
|
(PCC_FILE_SIZES)&Fcb->NTRequiredFCB->CommonFCBHeader.AllocationSize,
|
|
FALSE,
|
|
&(UDFGlobalData.CacheMgrCallBacks),
|
|
Fcb->NTRequiredFCB );
|
|
|
|
CacheMapInitialized = TRUE;
|
|
}
|
|
|
|
AcquiredPagingIo = UDFAcquireResourceExclusiveWithCheck(&(Fcb->NTRequiredFCB->PagingIoResource));
|
|
// Do a special case here for the lazy write of file sizes.
|
|
if(PtrSp->Parameters.SetFile.AdvanceOnly) {
|
|
// Never have the dirent filesize larger than the fcb filesize
|
|
PtrBuffer->EndOfFile.QuadPart =
|
|
min(PtrBuffer->EndOfFile.QuadPart,
|
|
NtReqFcb->CommonFCBHeader.FileSize.QuadPart);
|
|
// Only advance the file size, never reduce it with this call
|
|
RC = STATUS_SUCCESS;
|
|
if(UDFGetFileSizeFromDirNdx(Vcb, Fcb->FileInfo) >=
|
|
PtrBuffer->EndOfFile.QuadPart)
|
|
try_return(RC);
|
|
|
|
UDFSetFileSizeInDirNdx(Vcb, Fcb->FileInfo, &(PtrBuffer->EndOfFile.QuadPart));
|
|
goto notify_size_changes;
|
|
}
|
|
|
|
// !!! IMPORTANT !!!
|
|
|
|
// We can get here after all Handles to the file are closed
|
|
// To prevent allocation size incoherency we should
|
|
// reference FileInfo _before_ call to UDFResizeFile__()
|
|
// and use UDFCloseFile__() _after_ that
|
|
|
|
// Are we increasing the allocation size?
|
|
OldFileSize = NtReqFcb->CommonFCBHeader.FileSize.QuadPart;
|
|
if(OldFileSize < PtrBuffer->EndOfFile.QuadPart) {
|
|
|
|
// Yes. Do the FSD specific stuff i.e. increase reserved
|
|
// space on disk.
|
|
/*
|
|
if (FileObject->PrivateCacheMap)
|
|
ZeroBlock = TRUE;
|
|
*/
|
|
|
|
// reference file to pretend that it is opened
|
|
UDFReferenceFile__(Fcb->FileInfo);
|
|
UDFInterlockedIncrement((PLONG)&(Fcb->ReferenceCount));
|
|
UDFInterlockedIncrement((PLONG)&(NtReqFcb->CommonRefCount));
|
|
// perform resize operation
|
|
RC = UDFResizeFile__(Vcb, Fcb->FileInfo, PtrBuffer->EndOfFile.QuadPart);
|
|
// dereference file
|
|
UDFCloseFile__(Vcb, Fcb->FileInfo);
|
|
UDFInterlockedDecrement((PLONG)&(Fcb->ReferenceCount));
|
|
UDFInterlockedDecrement((PLONG)&(NtReqFcb->CommonRefCount));
|
|
// update values in NtReqFcb
|
|
NtReqFcb->CommonFCBHeader.FileSize.QuadPart =
|
|
// NtReqFcb->CommonFCBHeader.ValidDataLength.QuadPart =
|
|
PtrBuffer->EndOfFile.QuadPart;
|
|
ModifiedAllocSize = TRUE;
|
|
|
|
} else if(NtReqFcb->CommonFCBHeader.FileSize.QuadPart >
|
|
PtrBuffer->EndOfFile.QuadPart) {
|
|
|
|
// This is the painful part. See if the VMM will allow us to proceed.
|
|
// The VMM will deny the request if:
|
|
// (a) any image section exists OR
|
|
// (b) a data section exists and the size of the user mapped view
|
|
// is greater than the new size
|
|
// Otherwise, the VMM should allow the request to proceed.
|
|
|
|
MmPrint((" MmCanFileBeTruncated()\n"));
|
|
if(!MmCanFileBeTruncated(&(NtReqFcb->SectionObject), &(PtrBuffer->EndOfFile))) {
|
|
// VMM said no way!
|
|
try_return(RC = STATUS_USER_MAPPED_FILE);
|
|
}
|
|
|
|
// Perform directory entry modifications. Release any on-disk
|
|
// space we may need to in the process.
|
|
UDFReferenceFile__(Fcb->FileInfo);
|
|
UDFInterlockedIncrement((PLONG)&(Fcb->ReferenceCount));
|
|
UDFInterlockedIncrement((PLONG)&(NtReqFcb->CommonRefCount));
|
|
// perform resize operation
|
|
RC = UDFResizeFile__(Vcb, Fcb->FileInfo, PtrBuffer->EndOfFile.QuadPart);
|
|
// dereference file
|
|
UDFCloseFile__(Vcb, Fcb->FileInfo);
|
|
UDFInterlockedDecrement((PLONG)&(Fcb->ReferenceCount));
|
|
UDFInterlockedDecrement((PLONG)&(NtReqFcb->CommonRefCount));
|
|
|
|
ModifiedAllocSize = TRUE;
|
|
TruncatedFile = TRUE;
|
|
}
|
|
|
|
// This is a good place to check if we have performed a truncate
|
|
// operation. If we have perform a truncate (whether we extended
|
|
// or reduced file size), we should update file time stamps.
|
|
|
|
// Last, but not the least, we must inform the Cache Manager of file size changes.
|
|
if(ModifiedAllocSize && NT_SUCCESS(RC)) {
|
|
// If we decreased the allocation size to less than the
|
|
// current file size, modify the file size value.
|
|
// Similarly, if we decreased the value to less than the
|
|
// current valid data length, modify that value as well.
|
|
if(TruncatedFile) {
|
|
if(NtReqFcb->CommonFCBHeader.ValidDataLength.QuadPart >
|
|
PtrBuffer->EndOfFile.QuadPart) {
|
|
// Decrease the valid data length value.
|
|
NtReqFcb->CommonFCBHeader.ValidDataLength =
|
|
PtrBuffer->EndOfFile;
|
|
}
|
|
if(NtReqFcb->CommonFCBHeader.FileSize.QuadPart >
|
|
PtrBuffer->EndOfFile.QuadPart) {
|
|
// Decrease the file size value.
|
|
NtReqFcb->CommonFCBHeader.FileSize =
|
|
PtrBuffer->EndOfFile;
|
|
}
|
|
UDFSetFileSizeInDirNdx(Vcb, Fcb->FileInfo, NULL);
|
|
} else {
|
|
// Update the FCB Header with the new allocation size.
|
|
// NT expects AllocationSize to be decreased on Close only
|
|
NtReqFcb->CommonFCBHeader.AllocationSize.QuadPart =
|
|
PtrBuffer->EndOfFile.QuadPart;
|
|
// UDFSysGetAllocSize(Vcb, UDFGetFileSize(Fcb->FileInfo));
|
|
UDFSetFileSizeInDirNdx(Vcb, Fcb->FileInfo, &(PtrBuffer->EndOfFile.QuadPart));
|
|
}
|
|
|
|
FileObject->Flags |= FO_FILE_MODIFIED;
|
|
// UDFGetFileAllocationSize(Vcb, Fcb->FileInfo);
|
|
|
|
// If the FCB has not had caching initiated, it is still valid
|
|
// for us to invoke the NT Cache Manager. It is possible in such
|
|
// situations for the call to be no'oped (unless some user has
|
|
// mapped in the file)
|
|
|
|
// Archive bit
|
|
if(Vcb->CompatFlags & UDF_VCB_IC_UPDATE_ARCH_BIT) {
|
|
DirNdx = UDFDirIndex(UDFGetDirIndexByFileInfo(Fcb->FileInfo), Fcb->FileInfo->Index);
|
|
Ccb->CCBFlags &= ~UDF_CCB_ATTRIBUTES_SET;
|
|
Attr = UDFAttributesToNT(DirNdx, Fcb->FileInfo->Dloc->FileEntry);
|
|
if(!(Attr & FILE_ATTRIBUTE_ARCHIVE))
|
|
UDFAttributesToUDF(DirNdx, Fcb->FileInfo->Dloc->FileEntry, Attr | FILE_ATTRIBUTE_ARCHIVE);
|
|
}
|
|
|
|
// NOTE: The invocation to CcSetFileSizes() will quite possibly
|
|
// result in a recursive call back into the file system.
|
|
// This is because the NT Cache Manager will typically
|
|
// perform a flush before telling the VMM to purge pages
|
|
// especially when caching has not been initiated on the
|
|
// file stream, but the user has mapped the file into
|
|
// the process' virtual address space.
|
|
MmPrint((" CcSetFileSizes(), thrd:%8.8x\n",PsGetCurrentThread()));
|
|
Fcb->NTRequiredFCB->AcqFlushCount++;
|
|
CcSetFileSizes(FileObject, (PCC_FILE_SIZES)&(NtReqFcb->CommonFCBHeader.AllocationSize));
|
|
Fcb->NTRequiredFCB->AcqFlushCount--;
|
|
/* if(ZeroBlock) {
|
|
UDFZeroDataEx(NtReqFcb,
|
|
OldFileSize,
|
|
PtrBuffer->EndOfFile.QuadPart - OldFileSize,
|
|
TRUE // CanWait, Vcb, FileObject);
|
|
}*/
|
|
Fcb->NTRequiredFCB->NtReqFCBFlags |= UDF_NTREQ_FCB_MODIFIED;
|
|
|
|
notify_size_changes:
|
|
if(AcquiredPagingIo) {
|
|
UDFReleaseResource(&(Fcb->NTRequiredFCB->PagingIoResource));
|
|
AcquiredPagingIo = FALSE;
|
|
}
|
|
|
|
// Inform any pending IRPs (notify change directory).
|
|
if(UDFIsAStream(Fcb->FileInfo)) {
|
|
UDFNotifyFullReportChange( Vcb, Fcb->FileInfo,
|
|
FILE_NOTIFY_CHANGE_STREAM_SIZE,
|
|
FILE_ACTION_MODIFIED_STREAM);
|
|
} else {
|
|
UDFNotifyFullReportChange( Vcb, Fcb->FileInfo,
|
|
FILE_NOTIFY_CHANGE_SIZE,
|
|
FILE_ACTION_MODIFIED);
|
|
}
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
if(AcquiredPagingIo) {
|
|
UDFReleaseResource(&(Fcb->NTRequiredFCB->PagingIoResource));
|
|
AcquiredPagingIo = FALSE;
|
|
}
|
|
if (CacheMapInitialized) {
|
|
|
|
MmPrint((" CcUninitializeCacheMap()\n"));
|
|
CcUninitializeCacheMap( FileObject, NULL, NULL );
|
|
}
|
|
} _SEH2_END;
|
|
return(RC);
|
|
} // end UDFSetEOF()
|
|
|
|
NTSTATUS
|
|
UDFPrepareForRenameMoveLink(
|
|
PVCB Vcb,
|
|
PBOOLEAN AcquiredVcb,
|
|
PBOOLEAN AcquiredVcbEx,
|
|
PBOOLEAN SingleDir,
|
|
PBOOLEAN AcquiredDir1,
|
|
PBOOLEAN AcquiredFcb1,
|
|
IN PtrUDFCCB Ccb1,
|
|
PUDF_FILE_INFO File1,
|
|
PUDF_FILE_INFO Dir1,
|
|
PUDF_FILE_INFO Dir2,
|
|
BOOLEAN HardLink
|
|
)
|
|
{
|
|
// convert acquisition to Exclusive
|
|
// this will prevent us from the following situation:
|
|
// There is a pair of objects among input dirs &
|
|
// one of them is a parent of another. Sequential resource
|
|
// acquisition may lead to deadlock due to concurrent
|
|
// CleanUpFcbChain() or UDFCloseFileInfoChain()
|
|
UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCount));
|
|
UDFReleaseResource(&(Vcb->VCBResource));
|
|
(*AcquiredVcb) = FALSE;
|
|
|
|
// At first, make system to issue last Close request
|
|
// for our Source & Target ...
|
|
// we needn't flush/purge for Source on HLink
|
|
UDFRemoveFromSystemDelayedQueue(Dir2->Fcb);
|
|
if(!HardLink && (Dir2 != Dir1))
|
|
UDFRemoveFromSystemDelayedQueue(File1->Fcb);
|
|
|
|
#ifdef UDF_DELAYED_CLOSE
|
|
_SEH2_TRY {
|
|
// Do actual close for all "delayed close" calls
|
|
|
|
// ... and now remove the rest from our queue
|
|
if(!HardLink) {
|
|
UDFCloseAllDelayedInDir(Vcb, Dir1);
|
|
if(Dir2 != Dir1)
|
|
UDFCloseAllDelayedInDir(Vcb, Dir2);
|
|
} else {
|
|
UDFCloseAllDelayedInDir(Vcb, Dir2);
|
|
}
|
|
|
|
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
|
|
BrutePoint();
|
|
UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
|
|
return (STATUS_DRIVER_INTERNAL_ERROR);
|
|
} _SEH2_END;
|
|
#endif //UDF_DELAYED_CLOSE
|
|
|
|
(*SingleDir) = ((Dir1 == Dir2) && (Dir1->Fcb));
|
|
|
|
if(!(*SingleDir) ||
|
|
(UDFGetFileLinkCount(File1) != 1)) {
|
|
UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
|
|
(*AcquiredVcb) = TRUE;
|
|
(*AcquiredVcbEx) = TRUE;
|
|
UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
|
|
} else {
|
|
UDFAcquireResourceShared(&(Vcb->VCBResource), TRUE);
|
|
(*AcquiredVcb) = TRUE;
|
|
UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
|
|
|
|
UDF_CHECK_PAGING_IO_RESOURCE(Dir1->Fcb->NTRequiredFCB);
|
|
UDFAcquireResourceExclusive(&(Dir1->Fcb->NTRequiredFCB->MainResource),TRUE);
|
|
(*AcquiredDir1) = TRUE;
|
|
|
|
UDF_CHECK_PAGING_IO_RESOURCE(File1->Fcb->NTRequiredFCB);
|
|
UDFAcquireResourceExclusive(&(File1->Fcb->NTRequiredFCB->MainResource),TRUE);
|
|
(*AcquiredFcb1) = TRUE;
|
|
}
|
|
return STATUS_SUCCESS;
|
|
} // end UDFPrepareForRenameMoveLink()
|
|
|
|
/*
|
|
Rename or move file
|
|
*/
|
|
NTSTATUS
|
|
UDFRename(
|
|
IN PIO_STACK_LOCATION PtrSp,
|
|
IN PtrUDFFCB Fcb1,
|
|
IN PtrUDFCCB Ccb1,
|
|
IN PFILE_OBJECT FileObject1, // Source File
|
|
IN PFILE_RENAME_INFORMATION PtrBuffer
|
|
)
|
|
{
|
|
// Source Directory
|
|
PFILE_OBJECT DirObject1 = FileObject1->RelatedFileObject;
|
|
// Target Directory
|
|
PFILE_OBJECT DirObject2 = PtrSp->Parameters.SetFile.FileObject;
|
|
// Overwite Flag
|
|
BOOLEAN Replace = PtrSp->Parameters.SetFile.ReplaceIfExists &&
|
|
PtrBuffer->ReplaceIfExists;
|
|
NTSTATUS RC;
|
|
PVCB Vcb = Fcb1->Vcb;
|
|
PtrUDFFCB Fcb2;
|
|
BOOLEAN ic;
|
|
BOOLEAN AcquiredVcb = TRUE;
|
|
BOOLEAN AcquiredVcbEx = FALSE;
|
|
BOOLEAN AcquiredDir1 = FALSE;
|
|
BOOLEAN AcquiredFcb1 = FALSE;
|
|
BOOLEAN SingleDir = TRUE;
|
|
BOOLEAN UseClose;
|
|
|
|
PUDF_FILE_INFO File1;
|
|
PUDF_FILE_INFO Dir1;
|
|
PUDF_FILE_INFO Dir2;
|
|
PUDF_FILE_INFO NextFileInfo, fi;
|
|
|
|
UNICODE_STRING NewName;
|
|
UNICODE_STRING LocalPath;
|
|
PtrUDFCCB CurCcb = NULL;
|
|
PLIST_ENTRY Link;
|
|
ULONG i;
|
|
ULONG DirRefCount;
|
|
ULONG FileInfoRefCount;
|
|
ULONG Attr;
|
|
PDIR_INDEX_ITEM DirNdx;
|
|
|
|
AdPrint(("UDFRename %8.8x\n", DirObject2));
|
|
|
|
LocalPath.Buffer = NULL;
|
|
|
|
_SEH2_TRY {
|
|
// do we try to rename Volume ?
|
|
#ifdef UDF_ALLOW_RENAME_MOVE
|
|
if(!(File1 = Fcb1->FileInfo))
|
|
#endif //UDF_ALLOW_RENAME_MOVE
|
|
try_return (RC = STATUS_ACCESS_DENIED);
|
|
|
|
// do we try to rename RootDir ?
|
|
if(!(Dir1 = File1->ParentFile))
|
|
try_return (RC = STATUS_ACCESS_DENIED);
|
|
|
|
// do we try to rename to RootDir or Volume ?
|
|
if(!DirObject2) {
|
|
Dir2 = File1->ParentFile;
|
|
DirObject2 = DirObject1;
|
|
} else
|
|
if(DirObject2->FsContext2 &&
|
|
(Fcb2 = ((PtrUDFCCB)(DirObject2->FsContext2))->Fcb)) {
|
|
Dir2 = ((PtrUDFCCB)(DirObject2->FsContext2))->Fcb->FileInfo;
|
|
} else {
|
|
try_return (RC = STATUS_INVALID_PARAMETER);
|
|
}
|
|
// invalid destination ?
|
|
if(!Dir2) try_return (RC = STATUS_ACCESS_DENIED);
|
|
|
|
// Stream can't be a Dir or have StreamDir
|
|
if(UDFIsAStreamDir(Dir2)) {
|
|
#ifdef UDF_ENABLE_SECURITY
|
|
if(UDFIsADirectory(File1)) {
|
|
try_return (RC = STATUS_ACCESS_DENIED);
|
|
}
|
|
// We should check whether File1 has only Internal
|
|
// (or Deleted) streams. In this case SDir should be
|
|
// removed (in UDFRenameMoveFile__()). Otherwise
|
|
// return STATUS_ACCESS_DENIED
|
|
if(UDFHasAStreamDir(File1)) {
|
|
UDFPrint(("TODO: We should remove Streams from source file\n"));
|
|
try_return (RC = STATUS_ACCESS_DENIED);
|
|
}
|
|
#else //UDF_ENABLE_SECURITY
|
|
if(UDFIsADirectory(File1) ||
|
|
UDFHasAStreamDir(File1)) {
|
|
try_return (RC = STATUS_ACCESS_DENIED);
|
|
}
|
|
#endif //UDF_ENABLE_SECURITY
|
|
}
|
|
|
|
RC = UDFPrepareForRenameMoveLink(Vcb, &AcquiredVcb, &AcquiredVcbEx,
|
|
&SingleDir,
|
|
&AcquiredDir1, &AcquiredFcb1,
|
|
Ccb1, File1,
|
|
Dir1, Dir2,
|
|
FALSE); // it is Rename operation
|
|
if(!NT_SUCCESS(RC))
|
|
try_return(RC);
|
|
|
|
// check if the source file is in use
|
|
if(Fcb1->OpenHandleCount > 1)
|
|
try_return (RC = STATUS_ACCESS_DENIED);
|
|
ASSERT(Fcb1->OpenHandleCount);
|
|
ASSERT(!Fcb1->IrpContextLite);
|
|
if(Fcb1->IrpContextLite) {
|
|
try_return (RC = STATUS_ACCESS_DENIED);
|
|
}
|
|
// Check if we have parallel/pending Close threads
|
|
if(Fcb1->CcbCount && !SingleDir) {
|
|
// if this is the 1st attempt, we'll try to
|
|
// synchronize with Close requests
|
|
// otherwise fail request
|
|
RC = STATUS_ACCESS_DENIED;
|
|
post_rename:
|
|
if(Fcb1->FCBFlags & UDF_FCB_POSTED_RENAME) {
|
|
Fcb1->FCBFlags &= ~UDF_FCB_POSTED_RENAME;
|
|
try_return (RC);
|
|
}
|
|
Fcb1->FCBFlags |= UDF_FCB_POSTED_RENAME;
|
|
try_return (RC = STATUS_PENDING);
|
|
}
|
|
|
|
if(!DirObject2) {
|
|
// Make sure the name is of legal length.
|
|
if(PtrBuffer->FileNameLength > UDF_NAME_LEN*sizeof(WCHAR)) {
|
|
try_return(RC = STATUS_OBJECT_NAME_INVALID);
|
|
}
|
|
NewName.Length = NewName.MaximumLength = (USHORT)(PtrBuffer->FileNameLength);
|
|
NewName.Buffer = (PWCHAR)&(PtrBuffer->FileName);
|
|
} else {
|
|
// This name is by definition legal.
|
|
NewName = *((PUNICODE_STRING)&DirObject2->FileName);
|
|
}
|
|
|
|
ic = (Ccb1->CCBFlags & UDF_CCB_CASE_SENSETIVE) ? FALSE : TRUE;
|
|
|
|
AdPrint((" %ws ->\n %ws\n",
|
|
Fcb1->FCBName->ObjectName.Buffer,
|
|
NewName.Buffer));
|
|
|
|
if(UDFIsDirOpened__(File1)) {
|
|
// We can't rename file because of unclean references.
|
|
// UDF_INFO package can safely do it, but NT side cannot.
|
|
// In this case NT requires STATUS_OBJECT_NAME_COLLISION
|
|
// rather than STATUS_ACCESS_DENIED
|
|
if(NT_SUCCESS(UDFFindFile__(Vcb, ic, &NewName, Dir2)))
|
|
try_return(RC = STATUS_OBJECT_NAME_COLLISION);
|
|
try_return (RC = STATUS_ACCESS_DENIED);
|
|
} else {
|
|
// Last check before Moving.
|
|
// We can't move across Dir referenced (even internally) file
|
|
if(!SingleDir) {
|
|
RC = UDFDoesOSAllowFileToBeMoved__(File1);
|
|
if(!NT_SUCCESS(RC)) {
|
|
// try_return(RC);
|
|
goto post_rename;
|
|
}
|
|
}
|
|
|
|
ASSERT_REF(Fcb1->ReferenceCount >= File1->RefCount);
|
|
ASSERT_REF(Dir1->Fcb->ReferenceCount >= Dir1->RefCount);
|
|
ASSERT_REF(Dir2->Fcb->ReferenceCount >= Dir2->RefCount);
|
|
|
|
RC = UDFRenameMoveFile__(Vcb, ic, &Replace, &NewName, Dir1, Dir2, File1);
|
|
}
|
|
if(!NT_SUCCESS(RC))
|
|
try_return (RC);
|
|
|
|
ASSERT(UDFDirIndex(File1->ParentFile->Dloc->DirIndex, File1->Index)->FileInfo == File1);
|
|
|
|
RC = MyCloneUnicodeString(&LocalPath, (Dir2->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY) ?
|
|
&UDFGlobalData.UnicodeStrRoot :
|
|
&(Dir2->Fcb->FCBName->ObjectName) );
|
|
if(!NT_SUCCESS(RC)) try_return (RC);
|
|
// RC = MyAppendUnicodeStringToString(&LocalPath, (Dir2->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY) ? &(UDFGlobalData.UnicodeStrRoot) : &(Dir2->Fcb->FCBName->ObjectName));
|
|
// if(!NT_SUCCESS(RC)) try_return (RC);
|
|
if(Dir2->ParentFile) {
|
|
RC = MyAppendUnicodeToString(&LocalPath, L"\\");
|
|
if(!NT_SUCCESS(RC)) try_return (RC);
|
|
}
|
|
RC = MyAppendUnicodeStringToStringTag(&LocalPath, &NewName, MEM_USREN_TAG);
|
|
if(!NT_SUCCESS(RC)) try_return (RC);
|
|
|
|
// Set Archive bit
|
|
DirNdx = UDFDirIndex(File1->ParentFile->Dloc->DirIndex, File1->Index);
|
|
if(Vcb->CompatFlags & UDF_VCB_IC_UPDATE_ARCH_BIT) {
|
|
Attr = UDFAttributesToNT(DirNdx, File1->Dloc->FileEntry);
|
|
if(!(Attr & FILE_ATTRIBUTE_ARCHIVE))
|
|
UDFAttributesToUDF(DirNdx, File1->Dloc->FileEntry, Attr | FILE_ATTRIBUTE_ARCHIVE);
|
|
}
|
|
// Update Parent Objects (mark 'em as modified)
|
|
if(Vcb->CompatFlags & UDF_VCB_IC_UPDATE_DIR_WRITE) {
|
|
if(DirObject1)
|
|
DirObject1->Flags |= FO_FILE_MODIFIED;
|
|
if(DirObject2) {
|
|
DirObject2->Flags |= FO_FILE_MODIFIED;
|
|
if(!Replace)
|
|
DirObject2->Flags |= FO_FILE_SIZE_CHANGED;
|
|
}
|
|
}
|
|
// report changes
|
|
if(SingleDir && !Replace) {
|
|
UDFNotifyFullReportChange( Vcb, File1,
|
|
UDFIsADirectory(File1) ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME,
|
|
FILE_ACTION_RENAMED_OLD_NAME);
|
|
/* UDFNotifyFullReportChange( Vcb, File2,
|
|
UDFIsADirectory(File2) ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME,
|
|
FILE_ACTION_RENAMED_NEW_NAME );*/
|
|
FsRtlNotifyFullReportChange( Vcb->NotifyIRPMutex, &(Vcb->NextNotifyIRP),
|
|
(PSTRING)&LocalPath,
|
|
((Dir2->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY) ? 0 : Dir2->Fcb->FCBName->ObjectName.Length) + sizeof(WCHAR),
|
|
NULL,NULL,
|
|
UDFIsADirectory(File1) ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME,
|
|
FILE_ACTION_RENAMED_NEW_NAME,
|
|
NULL);
|
|
} else {
|
|
UDFNotifyFullReportChange( Vcb, File1,
|
|
UDFIsADirectory(File1) ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME,
|
|
FILE_ACTION_REMOVED);
|
|
if(Replace) {
|
|
/* UDFNotifyFullReportChange( Vcb, File2,
|
|
FILE_NOTIFY_CHANGE_ATTRIBUTES |
|
|
FILE_NOTIFY_CHANGE_SIZE |
|
|
FILE_NOTIFY_CHANGE_LAST_WRITE |
|
|
FILE_NOTIFY_CHANGE_LAST_ACCESS |
|
|
FILE_NOTIFY_CHANGE_CREATION |
|
|
FILE_NOTIFY_CHANGE_EA,
|
|
FILE_ACTION_MODIFIED );*/
|
|
FsRtlNotifyFullReportChange( Vcb->NotifyIRPMutex, &(Vcb->NextNotifyIRP),
|
|
(PSTRING)&LocalPath,
|
|
((Dir2->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY) ?
|
|
0 : Dir2->Fcb->FCBName->ObjectName.Length) + sizeof(WCHAR),
|
|
NULL,NULL,
|
|
FILE_NOTIFY_CHANGE_ATTRIBUTES |
|
|
FILE_NOTIFY_CHANGE_SIZE |
|
|
FILE_NOTIFY_CHANGE_LAST_WRITE |
|
|
FILE_NOTIFY_CHANGE_LAST_ACCESS |
|
|
FILE_NOTIFY_CHANGE_CREATION |
|
|
FILE_NOTIFY_CHANGE_EA,
|
|
FILE_ACTION_MODIFIED,
|
|
NULL);
|
|
} else {
|
|
/* UDFNotifyFullReportChange( Vcb, File2,
|
|
UDFIsADirectory(File2) ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME,
|
|
FILE_ACTION_ADDED );*/
|
|
FsRtlNotifyFullReportChange( Vcb->NotifyIRPMutex, &(Vcb->NextNotifyIRP),
|
|
(PSTRING)&LocalPath,
|
|
((Dir2->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY) ?
|
|
0 : Dir2->Fcb->FCBName->ObjectName.Length) + sizeof(WCHAR),
|
|
NULL,NULL,
|
|
UDFIsADirectory(File1) ?
|
|
FILE_NOTIFY_CHANGE_DIR_NAME :
|
|
FILE_NOTIFY_CHANGE_FILE_NAME,
|
|
FILE_ACTION_ADDED,
|
|
NULL);
|
|
}
|
|
}
|
|
|
|
// this will prevent structutre release before call to
|
|
// UDFCleanUpFcbChain()
|
|
UDFInterlockedIncrement((PLONG)&(Dir1->Fcb->ReferenceCount));
|
|
UDFInterlockedIncrement((PLONG)&(Dir1->Fcb->NTRequiredFCB->CommonRefCount));
|
|
ASSERT_REF(Dir1->Fcb->ReferenceCount >= Dir1->RefCount);
|
|
|
|
// Look through Ccb list & decrement OpenHandleCounter(s)
|
|
// acquire CcbList
|
|
if(!SingleDir) {
|
|
UDFAcquireResourceExclusive(&(Fcb1->CcbListResource),TRUE);
|
|
Link = Fcb1->NextCCB.Flink;
|
|
DirRefCount = 0;
|
|
FileInfoRefCount = 0;
|
|
ASSERT(Link != &(Fcb1->NextCCB));
|
|
while (Link != &(Fcb1->NextCCB)) {
|
|
NextFileInfo = Dir1;
|
|
CurCcb = CONTAINING_RECORD(Link, UDFCCB, NextCCB);
|
|
ASSERT(CurCcb->TreeLength);
|
|
i = (CurCcb->TreeLength) ? (CurCcb->TreeLength - 1) : 0;
|
|
Link = Link->Flink;
|
|
UseClose = (CurCcb->CCBFlags & UDF_CCB_CLEANED) ? FALSE : TRUE;
|
|
|
|
AdPrint((" Ccb:%x:%s:i:%x\n", CurCcb, UseClose ? "Close" : "",i));
|
|
// cleanup old parent chain
|
|
for(; i && NextFileInfo; i--) {
|
|
// remember parent file now
|
|
// it will prevent us from data losses
|
|
// due to eventual structure release
|
|
fi = NextFileInfo->ParentFile;
|
|
if(UseClose) {
|
|
ASSERT_REF(NextFileInfo->Fcb->ReferenceCount >= NextFileInfo->RefCount);
|
|
UDFCloseFile__(Vcb, NextFileInfo);
|
|
}
|
|
ASSERT_REF(NextFileInfo->Fcb->ReferenceCount > NextFileInfo->RefCount);
|
|
ASSERT_REF(NextFileInfo->Fcb->ReferenceCount);
|
|
ASSERT_REF(NextFileInfo->Fcb->NTRequiredFCB->CommonRefCount);
|
|
UDFInterlockedDecrement((PLONG)&(NextFileInfo->Fcb->ReferenceCount));
|
|
UDFInterlockedDecrement((PLONG)&(NextFileInfo->Fcb->NTRequiredFCB->CommonRefCount));
|
|
ASSERT_REF(NextFileInfo->Fcb->ReferenceCount >= NextFileInfo->RefCount);
|
|
NextFileInfo = fi;
|
|
}
|
|
|
|
if(CurCcb->TreeLength > 1) {
|
|
DirRefCount++;
|
|
if(UseClose)
|
|
FileInfoRefCount++;
|
|
CurCcb->TreeLength = 2;
|
|
#ifdef UDF_DBG
|
|
} else {
|
|
BrutePoint();
|
|
#endif // UDF_DBG
|
|
}
|
|
}
|
|
UDFReleaseResource(&(Fcb1->CcbListResource));
|
|
|
|
ASSERT_REF(DirRefCount >= FileInfoRefCount);
|
|
// update counters & pointers
|
|
Fcb1->ParentFcb = Dir2->Fcb;
|
|
// move references to Dir2
|
|
UDFInterlockedExchangeAdd((PLONG)&(Dir2->Fcb->ReferenceCount), DirRefCount);
|
|
UDFInterlockedExchangeAdd((PLONG)&(Dir2->Fcb->NTRequiredFCB->CommonRefCount), DirRefCount);
|
|
ASSERT_REF(Dir2->Fcb->ReferenceCount > Dir2->RefCount);
|
|
UDFReferenceFileEx__(Dir2,FileInfoRefCount);
|
|
ASSERT_REF(Dir2->Fcb->ReferenceCount >= Dir2->RefCount);
|
|
}
|
|
ASSERT_REF(Dir2->Fcb->ReferenceCount >= Dir2->RefCount);
|
|
ASSERT_REF(Dir2->RefCount);
|
|
|
|
ASSERT_REF(Dir1->Fcb->ReferenceCount >= Dir1->RefCount);
|
|
// Modify name in Fcb1
|
|
if(Fcb1->FCBName) {
|
|
if(Fcb1->FCBName->ObjectName.Buffer) {
|
|
MyFreePool__(Fcb1->FCBName->ObjectName.Buffer);
|
|
}
|
|
UDFReleaseObjectName(Fcb1->FCBName);
|
|
}
|
|
Fcb1->FCBName = UDFAllocateObjectName();
|
|
if(!(Fcb1->FCBName)) {
|
|
insuf_res:
|
|
BrutePoint();
|
|
// UDFCleanUpFcbChain()...
|
|
if(AcquiredFcb1) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(Fcb1->NTRequiredFCB);
|
|
UDFReleaseResource(&(Fcb1->NTRequiredFCB->MainResource));
|
|
AcquiredDir1 = FALSE;
|
|
}
|
|
if(AcquiredDir1) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(Dir1->Fcb->NTRequiredFCB);
|
|
UDFReleaseResource(&(Dir1->Fcb->NTRequiredFCB->MainResource));
|
|
AcquiredDir1 = FALSE;
|
|
}
|
|
UDFCleanUpFcbChain(Vcb, Dir1, 1, TRUE);
|
|
try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
|
|
}
|
|
|
|
RC = MyCloneUnicodeString(&(Fcb1->FCBName->ObjectName), &(Fcb2->FCBName->ObjectName));
|
|
if(!NT_SUCCESS(RC))
|
|
goto insuf_res;
|
|
/* RC = MyAppendUnicodeStringToString(&(Fcb1->FCBName->ObjectName), &(Fcb2->FCBName->ObjectName));
|
|
if(!NT_SUCCESS(RC))
|
|
goto insuf_res;*/
|
|
// if Dir2 is a RootDir, we shoud not append '\\' because
|
|
// uit will be the 2nd '\\' character (RootDir's name is also '\\')
|
|
if(Dir2->ParentFile) {
|
|
RC = MyAppendUnicodeToString(&(Fcb1->FCBName->ObjectName), L"\\");
|
|
if(!NT_SUCCESS(RC))
|
|
goto insuf_res;
|
|
}
|
|
RC = MyAppendUnicodeStringToStringTag(&(Fcb1->FCBName->ObjectName), &NewName, MEM_USREN2_TAG);
|
|
if(!NT_SUCCESS(RC))
|
|
goto insuf_res;
|
|
|
|
ASSERT_REF(Fcb1->ReferenceCount >= File1->RefCount);
|
|
ASSERT_REF(Dir1->Fcb->ReferenceCount >= Dir1->RefCount);
|
|
ASSERT_REF(Dir2->Fcb->ReferenceCount >= Dir2->RefCount);
|
|
|
|
RC = STATUS_SUCCESS;
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
|
|
if(AcquiredFcb1) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(Fcb1->NTRequiredFCB);
|
|
UDFReleaseResource(&(Fcb1->NTRequiredFCB->MainResource));
|
|
}
|
|
if(AcquiredDir1) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(Dir1->Fcb->NTRequiredFCB);
|
|
UDFReleaseResource(&(Dir1->Fcb->NTRequiredFCB->MainResource));
|
|
}
|
|
// perform protected structure release
|
|
if(NT_SUCCESS(RC) &&
|
|
(RC != STATUS_PENDING)) {
|
|
ASSERT(AcquiredVcb);
|
|
UDFCleanUpFcbChain(Vcb, Dir1, 1, TRUE);
|
|
ASSERT_REF(Fcb1->ReferenceCount >= File1->RefCount);
|
|
ASSERT_REF(Dir2->Fcb->ReferenceCount >= Dir2->RefCount);
|
|
}
|
|
|
|
if(AcquiredVcb) {
|
|
if(AcquiredVcbEx)
|
|
UDFConvertExclusiveToSharedLite(&(Vcb->VCBResource));
|
|
} else {
|
|
// caller assumes Vcb to be acquired shared
|
|
BrutePoint();
|
|
UDFAcquireResourceShared(&(Vcb->VCBResource), TRUE);
|
|
}
|
|
|
|
if(LocalPath.Buffer) {
|
|
MyFreePool__(LocalPath.Buffer);
|
|
}
|
|
} _SEH2_END;
|
|
|
|
return RC;
|
|
} // end UDFRename()
|
|
|
|
#endif //UDF_READ_ONLY_BUILD
|
|
|
|
LONG
|
|
UDFFindFileId(
|
|
IN PVCB Vcb,
|
|
IN LONGLONG Id
|
|
)
|
|
{
|
|
if(!Vcb->FileIdCache) return (-1);
|
|
for(ULONG i=0; i<Vcb->FileIdCount; i++) {
|
|
if(Vcb->FileIdCache[i].Id == Id) return i;
|
|
}
|
|
return (-1);
|
|
} // end UDFFindFileId()
|
|
|
|
LONG
|
|
UDFFindFreeFileId(
|
|
IN PVCB Vcb,
|
|
IN LONGLONG Id
|
|
)
|
|
{
|
|
if(!Vcb->FileIdCache) {
|
|
if(!(Vcb->FileIdCache = (PUDFFileIDCacheItem)MyAllocatePool__(NonPagedPool, sizeof(UDFFileIDCacheItem)*FILE_ID_CACHE_GRANULARITY)))
|
|
return (-1);
|
|
RtlZeroMemory(Vcb->FileIdCache, FILE_ID_CACHE_GRANULARITY*sizeof(UDFFileIDCacheItem));
|
|
Vcb->FileIdCount = FILE_ID_CACHE_GRANULARITY;
|
|
}
|
|
for(ULONG i=0; i<Vcb->FileIdCount; i++) {
|
|
if(!Vcb->FileIdCache[i].FullName.Buffer) return i;
|
|
}
|
|
if(!MyReallocPool__((PCHAR)(Vcb->FileIdCache), Vcb->FileIdCount*sizeof(UDFFileIDCacheItem),
|
|
(PCHAR*)&(Vcb->FileIdCache), (Vcb->FileIdCount+FILE_ID_CACHE_GRANULARITY)*sizeof(UDFFileIDCacheItem))) {
|
|
return (-1);
|
|
}
|
|
RtlZeroMemory(&(Vcb->FileIdCache[Vcb->FileIdCount]), FILE_ID_CACHE_GRANULARITY*sizeof(UDFFileIDCacheItem));
|
|
Vcb->FileIdCount += FILE_ID_CACHE_GRANULARITY;
|
|
return (Vcb->FileIdCount - FILE_ID_CACHE_GRANULARITY);
|
|
} // end UDFFindFreeFileId()
|
|
|
|
NTSTATUS
|
|
UDFStoreFileId(
|
|
IN PVCB Vcb,
|
|
IN PtrUDFCCB Ccb,
|
|
IN PUDF_FILE_INFO fi,
|
|
IN LONGLONG Id
|
|
)
|
|
{
|
|
LONG i;
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
|
|
if((i = UDFFindFileId(Vcb, Id)) == (-1)) {
|
|
if((i = UDFFindFreeFileId(Vcb, Id)) == (-1)) return STATUS_INSUFFICIENT_RESOURCES;
|
|
} else {
|
|
return STATUS_SUCCESS;
|
|
}
|
|
Vcb->FileIdCache[i].Id = Id;
|
|
Vcb->FileIdCache[i].CaseSens = (Ccb->CCBFlags & UDF_CCB_CASE_SENSETIVE) ? TRUE : FALSE;
|
|
RC = MyCloneUnicodeString(&(Vcb->FileIdCache[i].FullName), &(Ccb->Fcb->FCBName->ObjectName));
|
|
/* if(NT_SUCCESS(RC)) {
|
|
RC = MyAppendUnicodeStringToStringTag(&(Vcb->FileIdCache[i].FullName), &(Ccb->Fcb->FCBName->ObjectName), MEM_USFIDC_TAG);
|
|
}*/
|
|
return RC;
|
|
} // end UDFStoreFileId()
|
|
|
|
NTSTATUS
|
|
UDFRemoveFileId(
|
|
IN PVCB Vcb,
|
|
IN LONGLONG Id
|
|
)
|
|
{
|
|
LONG i;
|
|
|
|
if((i = UDFFindFileId(Vcb, Id)) == (-1)) return STATUS_INVALID_PARAMETER;
|
|
MyFreePool__(Vcb->FileIdCache[i].FullName.Buffer);
|
|
RtlZeroMemory(&(Vcb->FileIdCache[i]), sizeof(UDFFileIDCacheItem));
|
|
return STATUS_SUCCESS;
|
|
} // end UDFRemoveFileId()
|
|
|
|
VOID
|
|
UDFReleaseFileIdCache(
|
|
IN PVCB Vcb
|
|
)
|
|
{
|
|
if(!Vcb->FileIdCache) return;
|
|
for(ULONG i=0; i<Vcb->FileIdCount; i++) {
|
|
if(Vcb->FileIdCache[i].FullName.Buffer) {
|
|
MyFreePool__(Vcb->FileIdCache[i].FullName.Buffer);
|
|
}
|
|
}
|
|
MyFreePool__(Vcb->FileIdCache);
|
|
Vcb->FileIdCache = NULL;
|
|
Vcb->FileIdCount = 0;
|
|
} // end UDFReleaseFileIdCache()
|
|
|
|
NTSTATUS
|
|
UDFGetOpenParamsByFileId(
|
|
IN PVCB Vcb,
|
|
IN LONGLONG Id,
|
|
OUT PUNICODE_STRING* FName,
|
|
OUT BOOLEAN* CaseSens
|
|
)
|
|
{
|
|
LONG i;
|
|
|
|
if((i = UDFFindFileId(Vcb, Id)) == (-1)) return STATUS_NOT_FOUND;
|
|
(*FName) = &(Vcb->FileIdCache[i].FullName);
|
|
(*CaseSens) = !(Vcb->FileIdCache[i].CaseSens);
|
|
return STATUS_SUCCESS;
|
|
} // end UDFGetOpenParamsByFileId()
|
|
|
|
#ifndef UDF_READ_ONLY_BUILD
|
|
|
|
#ifdef UDF_ALLOW_HARD_LINKS
|
|
/*
|
|
create hard link for the file
|
|
*/
|
|
NTSTATUS
|
|
UDFHardLink(
|
|
IN PIO_STACK_LOCATION PtrSp,
|
|
IN PtrUDFFCB Fcb1,
|
|
IN PtrUDFCCB Ccb1,
|
|
IN PFILE_OBJECT FileObject1, // Source File
|
|
IN PFILE_LINK_INFORMATION PtrBuffer
|
|
)
|
|
{
|
|
// Target Directory
|
|
PFILE_OBJECT DirObject2 = PtrSp->Parameters.SetFile.FileObject;
|
|
// Overwite Flag
|
|
BOOLEAN Replace = PtrSp->Parameters.SetFile.ReplaceIfExists &&
|
|
PtrBuffer->ReplaceIfExists;
|
|
NTSTATUS RC;
|
|
PVCB Vcb = Fcb1->Vcb;
|
|
PtrUDFFCB Fcb2;
|
|
BOOLEAN ic;
|
|
BOOLEAN AcquiredVcb = TRUE;
|
|
BOOLEAN AcquiredVcbEx = FALSE;
|
|
BOOLEAN AcquiredDir1 = FALSE;
|
|
BOOLEAN AcquiredFcb1 = FALSE;
|
|
BOOLEAN SingleDir = TRUE;
|
|
|
|
PUDF_FILE_INFO File1;
|
|
PUDF_FILE_INFO Dir1 = NULL;
|
|
PUDF_FILE_INFO Dir2;
|
|
|
|
UNICODE_STRING NewName;
|
|
UNICODE_STRING LocalPath;
|
|
// PtrUDFCCB CurCcb = NULL;
|
|
|
|
AdPrint(("UDFHardLink\n"));
|
|
|
|
LocalPath.Buffer = NULL;
|
|
|
|
_SEH2_TRY {
|
|
|
|
// do we try to link Volume ?
|
|
if(!(File1 = Fcb1->FileInfo))
|
|
try_return (RC = STATUS_ACCESS_DENIED);
|
|
|
|
// do we try to link RootDir ?
|
|
if(!(Dir1 = File1->ParentFile))
|
|
try_return (RC = STATUS_ACCESS_DENIED);
|
|
|
|
// do we try to link Stream / Stream Dir ?
|
|
#ifdef UDF_ALLOW_LINKS_TO_STREAMS
|
|
if(UDFIsAStreamDir(File1))
|
|
try_return (RC = STATUS_ACCESS_DENIED);
|
|
#else //UDF_ALLOW_LINKS_TO_STREAMS
|
|
if(UDFIsAStream(File1) || UDFIsAStreamDir(File1) /*||
|
|
UDFIsADirectory(File1) || UDFHasAStreamDir(File1)*/)
|
|
try_return (RC = STATUS_ACCESS_DENIED);
|
|
#endif // UDF_ALLOW_LINKS_TO_STREAMS
|
|
|
|
// do we try to link to RootDir or Volume ?
|
|
if(!DirObject2) {
|
|
Dir2 = File1->ParentFile;
|
|
DirObject2 = FileObject1->RelatedFileObject;
|
|
} else
|
|
if(DirObject2->FsContext2 &&
|
|
(Fcb2 = ((PtrUDFCCB)(DirObject2->FsContext2))->Fcb)) {
|
|
Dir2 = ((PtrUDFCCB)(DirObject2->FsContext2))->Fcb->FileInfo;
|
|
} else {
|
|
try_return (RC = STATUS_INVALID_PARAMETER);
|
|
}
|
|
|
|
// check target dir
|
|
if(!Dir2) try_return (RC = STATUS_ACCESS_DENIED);
|
|
|
|
// Stream can't be a Dir or have Streams
|
|
if(UDFIsAStreamDir(Dir2)) {
|
|
try_return (RC = STATUS_ACCESS_DENIED);
|
|
/* if(UDFIsADirectory(File1) ||
|
|
UDFHasAStreamDir(File1)) {
|
|
BrutePoint();
|
|
try_return (RC = STATUS_ACCESS_DENIED);
|
|
}*/
|
|
}
|
|
|
|
/* if(UDFIsAStreamDir(Dir2))
|
|
try_return (RC = STATUS_ACCESS_DENIED);*/
|
|
|
|
RC = UDFPrepareForRenameMoveLink(Vcb, &AcquiredVcb, &AcquiredVcbEx,
|
|
&SingleDir,
|
|
&AcquiredDir1, &AcquiredFcb1,
|
|
Ccb1, File1,
|
|
Dir1, Dir2,
|
|
TRUE); // it is HLink operation
|
|
if(!NT_SUCCESS(RC))
|
|
try_return(RC);
|
|
|
|
// check if the source file is used
|
|
if(!DirObject2) {
|
|
// Make sure the name is of legal length.
|
|
if(PtrBuffer->FileNameLength > UDF_NAME_LEN*sizeof(WCHAR)) {
|
|
try_return(RC = STATUS_OBJECT_NAME_INVALID);
|
|
}
|
|
NewName.Length = NewName.MaximumLength = (USHORT)(PtrBuffer->FileNameLength);
|
|
NewName.Buffer = (PWCHAR)&(PtrBuffer->FileName);
|
|
} else {
|
|
// This name is by definition legal.
|
|
NewName = *((PUNICODE_STRING)&DirObject2->FileName);
|
|
}
|
|
|
|
ic = (Ccb1->CCBFlags & UDF_CCB_CASE_SENSETIVE) ? FALSE : TRUE;
|
|
|
|
AdPrint((" %ws ->\n %ws\n",
|
|
Fcb1->FCBName->ObjectName.Buffer,
|
|
NewName.Buffer));
|
|
|
|
RC = UDFHardLinkFile__(Vcb, ic, &Replace, &NewName, Dir1, Dir2, File1);
|
|
if(!NT_SUCCESS(RC)) try_return (RC);
|
|
|
|
// Update Parent Objects (mark 'em as modified)
|
|
if(Vcb->CompatFlags & UDF_VCB_IC_UPDATE_DIR_WRITE) {
|
|
if(DirObject2) {
|
|
DirObject2->Flags |= FO_FILE_MODIFIED;
|
|
if(!Replace)
|
|
DirObject2->Flags |= FO_FILE_SIZE_CHANGED;
|
|
}
|
|
}
|
|
// report changes
|
|
UDFNotifyFullReportChange( Vcb, File1,
|
|
FILE_NOTIFY_CHANGE_LAST_WRITE |
|
|
FILE_NOTIFY_CHANGE_LAST_ACCESS,
|
|
FILE_ACTION_MODIFIED );
|
|
|
|
RC = MyCloneUnicodeString(&LocalPath, (Dir2->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY) ?
|
|
&UDFGlobalData.UnicodeStrRoot :
|
|
&(Dir2->Fcb->FCBName->ObjectName));
|
|
if(!NT_SUCCESS(RC)) try_return (RC);
|
|
/* RC = MyAppendUnicodeStringToString(&LocalPath, (Dir2->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY) ? &(UDFGlobalData.UnicodeStrRoot) : &(Dir2->Fcb->FCBName->ObjectName));
|
|
if(!NT_SUCCESS(RC)) try_return (RC);*/
|
|
// if Dir2 is a RootDir, we shoud not append '\\' because
|
|
// it will be the 2nd '\\' character (RootDir's name is also '\\')
|
|
if(Dir2->ParentFile) {
|
|
RC = MyAppendUnicodeToString(&LocalPath, L"\\");
|
|
if(!NT_SUCCESS(RC)) try_return (RC);
|
|
}
|
|
RC = MyAppendUnicodeStringToStringTag(&LocalPath, &NewName, MEM_USHL_TAG);
|
|
if(!NT_SUCCESS(RC)) try_return (RC);
|
|
|
|
if(!Replace) {
|
|
/* UDFNotifyFullReportChange( Vcb, File2,
|
|
UDFIsADirectory(File1) ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME,
|
|
FILE_ACTION_ADDED );*/
|
|
FsRtlNotifyFullReportChange( Vcb->NotifyIRPMutex, &(Vcb->NextNotifyIRP),
|
|
(PSTRING)&LocalPath,
|
|
((Dir2->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY) ? 0 : Dir2->Fcb->FCBName->ObjectName.Length) + sizeof(WCHAR),
|
|
NULL,NULL,
|
|
UDFIsADirectory(File1) ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME,
|
|
FILE_ACTION_ADDED,
|
|
NULL);
|
|
} else {
|
|
/* UDFNotifyFullReportChange( Vcb, File2,
|
|
FILE_NOTIFY_CHANGE_ATTRIBUTES |
|
|
FILE_NOTIFY_CHANGE_SIZE |
|
|
FILE_NOTIFY_CHANGE_LAST_WRITE |
|
|
FILE_NOTIFY_CHANGE_LAST_ACCESS |
|
|
FILE_NOTIFY_CHANGE_CREATION |
|
|
FILE_NOTIFY_CHANGE_EA,
|
|
FILE_ACTION_MODIFIED );*/
|
|
FsRtlNotifyFullReportChange( Vcb->NotifyIRPMutex, &(Vcb->NextNotifyIRP),
|
|
(PSTRING)&LocalPath,
|
|
((Dir2->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY) ? 0 : Dir2->Fcb->FCBName->ObjectName.Length) + sizeof(WCHAR),
|
|
NULL,NULL,
|
|
UDFIsADirectory(File1) ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME,
|
|
FILE_NOTIFY_CHANGE_ATTRIBUTES |
|
|
FILE_NOTIFY_CHANGE_SIZE |
|
|
FILE_NOTIFY_CHANGE_LAST_WRITE |
|
|
FILE_NOTIFY_CHANGE_LAST_ACCESS |
|
|
FILE_NOTIFY_CHANGE_CREATION |
|
|
FILE_NOTIFY_CHANGE_EA,
|
|
NULL);
|
|
}
|
|
|
|
RC = STATUS_SUCCESS;
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
|
|
if(AcquiredFcb1) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(Fcb1->NTRequiredFCB);
|
|
UDFReleaseResource(&(Fcb1->NTRequiredFCB->MainResource));
|
|
}
|
|
if(AcquiredDir1) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(Dir1->Fcb->NTRequiredFCB);
|
|
UDFReleaseResource(&(Dir1->Fcb->NTRequiredFCB->MainResource));
|
|
}
|
|
if(AcquiredVcb) {
|
|
if(AcquiredVcbEx)
|
|
UDFConvertExclusiveToSharedLite(&(Vcb->VCBResource));
|
|
} else {
|
|
// caller assumes Vcb to be acquired shared
|
|
BrutePoint();
|
|
UDFAcquireResourceShared(&(Vcb->VCBResource), TRUE);
|
|
}
|
|
|
|
if(LocalPath.Buffer) {
|
|
MyFreePool__(LocalPath.Buffer);
|
|
}
|
|
} _SEH2_END;
|
|
|
|
return RC;
|
|
} // end UDFHardLink()
|
|
#endif //UDF_ALLOW_HARD_LINKS
|
|
|
|
#endif //UDF_READ_ONLY_BUILD
|