|
|
/*++
Copyright (c) 1993 Microsoft Corporation
Module Name:
fileinfo.c
Abstract:
This module implements the get / set file information routines for Netware Redirector.
Author:
Manny Weiser (mannyw) 4-Mar-1993
Revision History:
--*/
#include "procs.h"
//
// The debug trace level
//
#define Dbg (DEBUG_TRACE_FILEINFO)
//
// local procedure prototypes
//
NTSTATUSNwCommonQueryInformation ( IN PIRP_CONTEXT pIrpContext );
NTSTATUSNwCommonSetInformation ( IN PIRP_CONTEXT pIrpContet );
NTSTATUSNwQueryBasicInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_BASIC_INFORMATION Buffer );
NTSTATUSNwQueryStandardInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_STANDARD_INFORMATION Buffer );
NTSTATUSNwQueryInternalInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_INTERNAL_INFORMATION Buffer );
NTSTATUSNwQueryEaInfo ( IN PIRP_CONTEXT IrpContext, IN PFILE_EA_INFORMATION Buffer );
NTSTATUSNwQueryNameInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_NAME_INFORMATION Buffer, IN OUT PULONG Length );
NTSTATUSNwQueryAltNameInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_NAME_INFORMATION Buffer, IN OUT PULONG Length );
NTSTATUSNwQueryPositionInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_POSITION_INFORMATION Buffer );
NTSTATUSNwSetBasicInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_BASIC_INFORMATION Buffer );
NTSTATUSNwSetDispositionInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_DISPOSITION_INFORMATION Buffer );
NTSTATUSNwSetRenameInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_RENAME_INFORMATION Buffer );
NTSTATUSNwSetPositionInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_POSITION_INFORMATION Buffer );
NTSTATUSNwSetAllocationInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_ALLOCATION_INFORMATION Buffer );
NTSTATUSNwSetEndOfFileInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_END_OF_FILE_INFORMATION Buffer );
#ifdef ALLOC_PRAGMA
#pragma alloc_text( PAGE, NwFsdQueryInformation )
#pragma alloc_text( PAGE, NwFsdSetInformation )
#pragma alloc_text( PAGE, NwCommonQueryInformation )
#pragma alloc_text( PAGE, NwCommonSetInformation )
#pragma alloc_text( PAGE, NwQueryStandardInfo )
#pragma alloc_text( PAGE, NwQueryInternalInfo )
#pragma alloc_text( PAGE, NwQueryEaInfo )
#pragma alloc_text( PAGE, NwQueryNameInfo )
#pragma alloc_text( PAGE, NwQueryPositionInfo )
#pragma alloc_text( PAGE, NwSetBasicInfo )
#pragma alloc_text( PAGE, NwSetDispositionInfo )
#pragma alloc_text( PAGE, NwDeleteFile )
#pragma alloc_text( PAGE, NwSetRenameInfo )
#pragma alloc_text( PAGE, NwSetPositionInfo )
#pragma alloc_text( PAGE, NwSetAllocationInfo )
#pragma alloc_text( PAGE, NwSetEndOfFileInfo )
#pragma alloc_text( PAGE, OccurenceCount )
#ifndef QFE_BUILD
#pragma alloc_text( PAGE1, NwQueryBasicInfo )
#endif
#endif
#if 0 // Not pageable
// see ifndef QFE_BUILD above
#endif
NTSTATUSNwFsdQueryInformation ( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp )
/*++
Routine Description:
This routine implements the FSD part of the NtQueryInformationFile API calls.
Arguments:
DeviceObject - Supplies a pointer to the device object to use.
Irp - Supplies a pointer to the Irp to process.
Return Value:
NTSTATUS - The Fsd status for the Irp
--*/
{ NTSTATUS status; PIRP_CONTEXT pIrpContext = NULL; BOOLEAN TopLevel;
PAGED_CODE();
DebugTrace(+1, Dbg, "NwFsdQueryInformation\n", 0);
//
// Call the common query information routine.
//
FsRtlEnterFileSystem(); TopLevel = NwIsIrpTopLevel( Irp );
try {
pIrpContext = AllocateIrpContext( Irp ); status = NwCommonQueryInformation( pIrpContext );
} except(NwExceptionFilter( Irp, GetExceptionInformation() )) {
if ( pIrpContext == NULL ) {
//
// If we couldn't allocate an irp context, just complete
// irp without any fanfare.
//
status = STATUS_INSUFFICIENT_RESOURCES; Irp->IoStatus.Status = status; Irp->IoStatus.Information = 0; IoCompleteRequest ( Irp, IO_NETWORK_INCREMENT );
} else {
//
// We had some trouble trying to perform the requested
// operation, so we'll abort the I/O request with
// the error Status that we get back from the
// execption code
//
status = NwProcessException( pIrpContext, GetExceptionCode() ); } }
if ( pIrpContext ) {
if ( status != STATUS_PENDING ) { NwDequeueIrpContext( pIrpContext, FALSE ); }
NwCompleteRequest( pIrpContext, status ); }
if ( TopLevel ) { NwSetTopLevelIrp( NULL ); } FsRtlExitFileSystem();
//
// Return to the caller.
//
DebugTrace(-1, Dbg, "NwFsdQueryInformation -> %08lx\n", status );
return status;}
NTSTATUSNwFsdSetInformation ( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp )/*++
Routine Description:
This routine implements the FSD part of the NtSetInformationFile API calls.
Arguments:
DeviceObject - Supplies the device object to use.
Irp - Supplies the Irp being processed
Return Value:
NTSTATUS - The Fsd status for the Irp
--*/{ NTSTATUS status; PIRP_CONTEXT pIrpContext = NULL; BOOLEAN TopLevel;
PAGED_CODE();
DebugTrace(+1, Dbg, "NwFsdSetInformation\n", 0);
//
// Call the common Set Information routine.
//
FsRtlEnterFileSystem(); TopLevel = NwIsIrpTopLevel( Irp );
try {
pIrpContext = AllocateIrpContext( Irp ); status = NwCommonSetInformation( pIrpContext );
} except(NwExceptionFilter( Irp, GetExceptionInformation() )) {
if ( pIrpContext == NULL ) {
//
// If we couldn't allocate an irp context, just complete
// irp without any fanfare.
//
status = STATUS_INSUFFICIENT_RESOURCES; Irp->IoStatus.Status = status; Irp->IoStatus.Information = 0; IoCompleteRequest ( Irp, IO_NETWORK_INCREMENT );
} else {
//
// We had some trouble trying to perform the requested
// operation, so we'll abort the I/O request with
// the error Status that we get back from the
// execption code
//
status = NwProcessException( pIrpContext, GetExceptionCode() ); }
}
if ( pIrpContext ) {
if ( status != STATUS_PENDING ) { NwDequeueIrpContext( pIrpContext, FALSE ); }
NwCompleteRequest( pIrpContext, status ); }
if ( TopLevel ) { NwSetTopLevelIrp( NULL ); } FsRtlExitFileSystem();
//
// Return to the caller.
//
DebugTrace(-1, Dbg, "NwFsdSetInformation -> %08lx\n", status );
return status;}
NTSTATUSNwCommonQueryInformation ( IN PIRP_CONTEXT pIrpContext )/*++
Routine Description:
This is the common routine for querying information on a file.
Arguments:
pIrpContext - Supplies Irp context information.
Return Value:
NTSTATUS - the return status for the operation.
--*/{ PIRP Irp; PIO_STACK_LOCATION irpSp; NTSTATUS status;
ULONG length; FILE_INFORMATION_CLASS fileInformationClass; PVOID buffer;
NODE_TYPE_CODE nodeTypeCode; PICB icb; PFCB fcb;
PVOID fsContext, fsContext2;
PFILE_ALL_INFORMATION AllInfo;
PAGED_CODE();
//
// Get the current stack location.
//
Irp = pIrpContext->pOriginalIrp; irpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace(+1, Dbg, "NwCommonQueryInformation...\n", 0); DebugTrace( 0, Dbg, " Irp = %08lx\n", (ULONG_PTR)Irp); DebugTrace( 0, Dbg, " ->Length = %08lx\n", irpSp->Parameters.QueryFile.Length); DebugTrace( 0, Dbg, " ->FileInformationClass = %08lx\n", irpSp->Parameters.QueryFile.FileInformationClass); DebugTrace( 0, Dbg, " ->Buffer = %08lx\n", (ULONG_PTR)Irp->AssociatedIrp.SystemBuffer);
//
// Find out who are.
//
if ((nodeTypeCode = NwDecodeFileObject( irpSp->FileObject, &fsContext, &fsContext2 )) == NTC_UNDEFINED) {
status = STATUS_INVALID_HANDLE;
DebugTrace(-1, Dbg, "NwCommonQueryInformation -> %08lx\n", status ); return status; }
//
// Make sure that this the user is querying an ICB.
//
switch (nodeTypeCode) {
case NW_NTC_ICB:
icb = (PICB)fsContext2; break;
default: // This is an illegal file object to query
DebugTrace(0, Dbg, "Node type code is not incorrect\n", 0);
DebugTrace(-1, Dbg, "NwCommonQueryInformation -> STATUS_INVALID_PARAMETER\n", 0); return STATUS_INVALID_PARAMETER; }
pIrpContext->Icb = icb;
//
// Make local copies of the input parameters.
//
length = irpSp->Parameters.QueryFile.Length; fileInformationClass = irpSp->Parameters.QueryFile.FileInformationClass; buffer = Irp->AssociatedIrp.SystemBuffer;
//
// Now acquire shared access to the FCB
//
fcb = icb->SuperType.Fcb;
try {
NwVerifyIcbSpecial( icb );
//
// Based on the information class we'll do different actions. Each
// of the procedure that we're calling fill up as much of the
// buffer as possible and return the remaining length, and status
// This is done so that we can use them to build up the
// FileAllInformation request. These procedures do not complete the
// IRP, instead this procedure must complete the IRP.
//
status = STATUS_SUCCESS;
switch (fileInformationClass) {
case FileAllInformation:
AllInfo = buffer;
//
// First call all the Query Info handlers we can call
// synchronously.
//
NwQueryInternalInfo( pIrpContext, icb, &AllInfo->InternalInformation ); NwQueryEaInfo( pIrpContext, &AllInfo->EaInformation ); NwQueryPositionInfo( pIrpContext, icb, &AllInfo->PositionInformation );
length -= FIELD_OFFSET( FILE_ALL_INFORMATION, NameInformation );
status = NwQueryNameInfo( pIrpContext, icb, &AllInfo->NameInformation, &length );
if ( !NT_ERROR( status ) ) { status = NwQueryStandardInfo( pIrpContext, icb, &AllInfo->StandardInformation ); }
if ( !NT_ERROR( status ) ) { status = NwQueryBasicInfo( pIrpContext, icb, &AllInfo->BasicInformation ); }
break;
case FileBasicInformation:
length -= sizeof( FILE_BASIC_INFORMATION ); status = NwQueryBasicInfo( pIrpContext, icb, buffer );
break;
case FileStandardInformation:
//
// We will handle this call for information asynchronously.
// The callback routine will fill in the missing data, and
// complete the IRP.
//
// Remember the buffer length, and status to return.
//
length -= sizeof( FILE_STANDARD_INFORMATION ); status = NwQueryStandardInfo( pIrpContext, icb, buffer ); break;
case FileInternalInformation:
status = NwQueryInternalInfo( pIrpContext, icb, buffer ); length -= sizeof( FILE_INTERNAL_INFORMATION ); break;
case FileEaInformation:
status = NwQueryEaInfo( pIrpContext, buffer ); length -= sizeof( FILE_EA_INFORMATION ); break;
case FilePositionInformation:
status = NwQueryPositionInfo( pIrpContext, icb, buffer ); length -= sizeof( FILE_POSITION_INFORMATION ); break;
case FileNameInformation:
status = NwQueryNameInfo( pIrpContext, icb, buffer, &length ); break;
case FileAlternateNameInformation:
if (!DisableAltFileName) { status = NwQueryAltNameInfo( pIrpContext, icb, buffer, &length); break; }
default:
status = STATUS_INVALID_PARAMETER; break; }
//
// Set the information field to the number of bytes actually
// filled in and then complete the request. (This is
// irrelavent if the Query worker function returned
// STATUS_PENDING).
//
if ( status != STATUS_PENDING ) { Irp->IoStatus.Information = irpSp->Parameters.QueryFile.Length - length; }
} finally {
DebugTrace(-1, Dbg, "NwCommonQueryInformation -> %08lx\n", status ); }
return status;}
NTSTATUSNwCommonSetInformation ( IN PIRP_CONTEXT IrpContext )/*++
Routine Description:
This is the common routine for setting information on a file.
Arguments:
IrpContext - Supplies the Irp to process
Return Value:
NTSTATUS - the return status for the operation
--*/{ PIRP irp; PIO_STACK_LOCATION irpSp; NTSTATUS status;
ULONG length; FILE_INFORMATION_CLASS fileInformationClass; PVOID buffer;
NODE_TYPE_CODE nodeTypeCode; PICB icb; PFCB fcb; PVOID fsContext;
//
// Get the current Irp stack location.
//
irp = IrpContext->pOriginalIrp; irpSp = IoGetCurrentIrpStackLocation( irp );
DebugTrace(+1, Dbg, "NwCommonSetInformation...\n", 0); DebugTrace( 0, Dbg, " Irp = %08lx\n", (ULONG_PTR)irp); DebugTrace( 0, Dbg, " ->Length = %08lx\n", irpSp->Parameters.SetFile.Length); DebugTrace( 0, Dbg, " ->FileInformationClass = %08lx\n", irpSp->Parameters.SetFile.FileInformationClass); DebugTrace( 0, Dbg, " ->Buffer = %08lx\n", (ULONG_PTR)irp->AssociatedIrp.SystemBuffer);
//
// Get a pointer to the FCB and ensure that this is a server side
// handler to a file.
//
if ((nodeTypeCode = NwDecodeFileObject( irpSp->FileObject, &fsContext, (PVOID *)&icb )) == NTC_UNDEFINED ) {
status = STATUS_INVALID_HANDLE;
DebugTrace(-1, Dbg, "NwCommonSetInformation -> %08lx\n", status ); return status; }
//
// Make sure that this the user is querying an ICB.
//
switch (nodeTypeCode) {
case NW_NTC_ICB:
fcb = icb->SuperType.Fcb; break;
default: // This is an illegal file object to query
DebugTrace(0, Dbg, "Node type code is not incorrect\n", 0);
DebugTrace(-1, Dbg, "NwCommonSetInformation -> STATUS_INVALID_PARAMETER\n", 0); return STATUS_INVALID_PARAMETER; }
IrpContext->Icb = icb;
//
// Make local copies of the input parameters.
//
length = irpSp->Parameters.SetFile.Length; fileInformationClass = irpSp->Parameters.SetFile.FileInformationClass; buffer = irp->AssociatedIrp.SystemBuffer;
try {
NwVerifyIcb( icb );
//
// Based on the information class we'll do different actions. Each
// procedure that we're calling will complete the request.
//
switch (fileInformationClass) {
case FileBasicInformation:
status = NwSetBasicInfo( IrpContext, icb, buffer ); break;
case FileDispositionInformation:
status = NwSetDispositionInfo( IrpContext, icb, buffer ); break;
case FileRenameInformation:
status = NwSetRenameInfo( IrpContext, icb, buffer ); break;
case FilePositionInformation:
status = NwSetPositionInfo( IrpContext, icb, buffer ); break;
case FileLinkInformation:
status = STATUS_INVALID_DEVICE_REQUEST; break;
case FileAllocationInformation:
status = NwSetAllocationInfo( IrpContext, icb, buffer ); break;
case FileEndOfFileInformation:
status = NwSetEndOfFileInfo( IrpContext, icb, buffer ); break;
default:
status = STATUS_INVALID_PARAMETER; break; }
} finally {
DebugTrace(-1, Dbg, "NwCommonSetInformation -> %08lx\n", status); }
return status;}
NTSTATUSNwQueryBasicInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, OUT PFILE_BASIC_INFORMATION Buffer )/*++
Routine Description:
This routine performs the query basic information operation. This routine cannot be paged, it is called from QueryStandardInfoCallback.
Arguments:
Icb - Supplies a pointer the ICB for the file being querying.
Buffer - Supplies a pointer to the buffer where the information is to be returned.
Return Value:
VOID
--*/
{ PFCB Fcb; NTSTATUS Status; ULONG Attributes; USHORT CreationDate; USHORT CreationTime = DEFAULT_TIME; USHORT LastAccessDate; USHORT LastModifiedDate; USHORT LastModifiedTime; BOOLEAN FirstTime = TRUE;
DebugTrace(0, Dbg, "QueryBasicInfo...\n", 0);
//
// Zero out the buffer.
//
RtlZeroMemory( Buffer, sizeof(FILE_BASIC_INFORMATION) ); Fcb = Icb->SuperType.Fcb;
//
// It is ok to attempt a reconnect if this request fails with a
// connection error.
//
SetFlag( IrpContext->Flags, IRP_FLAG_RECONNECTABLE );
NwAcquireSharedFcb( Fcb->NonPagedFcb, TRUE );
//
// If we already know the file attributes, simply return them.
//
if ( FlagOn( Fcb->Flags, FCB_FLAGS_ATTRIBUTES_ARE_VALID ) ) {
//
// Set the various fields in the record
//
Buffer->CreationTime = NwDateTimeToNtTime( Fcb->CreationDate, Fcb->CreationTime );
Buffer->LastAccessTime = NwDateTimeToNtTime( Fcb->LastAccessDate, DEFAULT_TIME );
Buffer->LastWriteTime = NwDateTimeToNtTime( Fcb->LastModifiedDate, Fcb->LastModifiedTime );
Buffer->ChangeTime.QuadPart = 0;
DebugTrace(0, Dbg, "QueryBasic known %wZ\n", &Fcb->RelativeFileName); DebugTrace(0, Dbg, "LastModifiedDate %x\n", Fcb->LastModifiedDate); DebugTrace(0, Dbg, "LastModifiedTime %x\n", Fcb->LastModifiedTime); DebugTrace(0, Dbg, "CreationDate %x\n", Fcb->CreationDate ); DebugTrace(0, Dbg, "CreationTime %x\n", Fcb->CreationTime ); DebugTrace(0, Dbg, "LastAccessDate %x\n", Fcb->LastAccessDate );
Buffer->FileAttributes = Fcb->NonPagedFcb->Attributes;
if ( Buffer->FileAttributes == 0 ) { Buffer->FileAttributes = FILE_ATTRIBUTE_NORMAL; }
NwReleaseFcb( Fcb->NonPagedFcb ); return STATUS_SUCCESS;
} else if ( Fcb->RelativeFileName.Length == 0 ) {
//
// Allow 'cd \' to work.
//
Buffer->FileAttributes = FILE_ATTRIBUTE_DIRECTORY;
Buffer->CreationTime = NwDateTimeToNtTime( DEFAULT_DATE, DEFAULT_TIME );
Buffer->LastAccessTime = Buffer->CreationTime; Buffer->LastWriteTime = Buffer->CreationTime; Buffer->ChangeTime.QuadPart = 0;
NwReleaseFcb( Fcb->NonPagedFcb ); return STATUS_SUCCESS;
} else {
NwReleaseFcb( Fcb->NonPagedFcb );
IrpContext->pNpScb = Fcb->Scb->pNpScb;Retry: if ( !BooleanFlagOn( Fcb->Flags, FCB_FLAGS_LONG_NAME ) ) {
DebugTrace(0, Dbg, "QueryBasic short %wZ\n", &Fcb->RelativeFileName);
Status = ExchangeWithWait ( IrpContext, SynchronousResponseCallback, "FwbbJ", NCP_SEARCH_FILE, -1, Fcb->Vcb->Specific.Disk.Handle, Fcb->NodeTypeCode == NW_NTC_FCB ? SEARCH_ALL_FILES : SEARCH_ALL_DIRECTORIES, &Icb->SuperType.Fcb->RelativeFileName );
if ( NT_SUCCESS( Status ) ) {
Status = ParseResponse( IrpContext, IrpContext->rsp, IrpContext->ResponseLength, "N==_b-==wwww", 14, &Attributes, &CreationDate, &LastAccessDate, &LastModifiedDate, &LastModifiedTime);
//
// If this was a directory, there's no usable
// time/date info from the server.
//
if ( ( NT_SUCCESS( Status ) ) && ( Attributes & NW_ATTRIBUTE_DIRECTORY ) ) {
CreationDate = DEFAULT_DATE; LastAccessDate = DEFAULT_DATE; LastModifiedDate = DEFAULT_DATE; LastModifiedTime = DEFAULT_TIME;
} }
} else {
DebugTrace(0, Dbg, "QueryBasic long %wZ\n", &Fcb->RelativeFileName);
Status = ExchangeWithWait ( IrpContext, SynchronousResponseCallback, "LbbWDbDbC", NCP_LFN_GET_INFO, Fcb->Vcb->Specific.Disk.LongNameSpace, Fcb->Vcb->Specific.Disk.LongNameSpace, Fcb->NodeTypeCode == NW_NTC_FCB ? SEARCH_ALL_FILES : SEARCH_ALL_DIRECTORIES, LFN_FLAG_INFO_ATTRIBUTES | LFN_FLAG_INFO_MODIFY_TIME | LFN_FLAG_INFO_CREATION_TIME, Fcb->Vcb->Specific.Disk.VolumeNumber, Fcb->Vcb->Specific.Disk.Handle, 0, &Icb->SuperType.Fcb->RelativeFileName );
if ( NT_SUCCESS( Status ) ) { Status = ParseResponse( IrpContext, IrpContext->rsp, IrpContext->ResponseLength, "N_e_xx_xx_x", 4, &Attributes, 12, &CreationTime, &CreationDate, 4, &LastModifiedTime, &LastModifiedDate, 4, &LastAccessDate );
} }
if ( NT_SUCCESS( Status ) ) {
//
// Set the various fields in the record
//
Buffer->CreationTime = NwDateTimeToNtTime( CreationDate, CreationTime );
Buffer->LastAccessTime = NwDateTimeToNtTime( LastAccessDate, DEFAULT_TIME );
Buffer->LastWriteTime = NwDateTimeToNtTime( LastModifiedDate, LastModifiedTime );
Buffer->ChangeTime.QuadPart = 0;
DebugTrace(0, Dbg, "CreationDate %x\n", CreationDate ); DebugTrace(0, Dbg, "CreationTime %x\n", CreationTime ); DebugTrace(0, Dbg, "LastAccessDate %x\n", LastAccessDate ); DebugTrace(0, Dbg, "LastModifiedDate %x\n", LastModifiedDate); DebugTrace(0, Dbg, "LastModifiedTime %x\n", LastModifiedTime);
Buffer->FileAttributes = (UCHAR)Attributes;
if ( Buffer->FileAttributes == 0 ) { Buffer->FileAttributes = FILE_ATTRIBUTE_NORMAL; }
} else if ((Status == STATUS_INVALID_HANDLE) && (FirstTime)) {
//
// Check to see if Volume handle is invalid. Caused when volume
// is unmounted and then remounted.
//
FirstTime = FALSE;
NwReopenVcbHandle( IrpContext, Fcb->Vcb );
goto Retry; }
return( Status ); }}
#if NWFASTIO
BOOLEANNwFastQueryBasicInfo ( IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, IN OUT PFILE_BASIC_INFORMATION Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject )
/*++
Routine Description:
This routine is for the fast query call for standard file information.
Arguments:
FileObject - Supplies the file object used in this operation
Wait - Indicates if we are allowed to wait for the information
Buffer - Supplies the output buffer to receive the basic information
IoStatus - Receives the final status of the operation
Return Value:
BOOLEAN - TRUE if the operation succeeded and FALSE if the caller needs to take the long route.
--*/
{ NODE_TYPE_CODE NodeTypeCode; PICB Icb; PFCB Fcb; PVOID FsContext;
FsRtlEnterFileSystem();
try { //
// Find out who are.
//
if ((NodeTypeCode = NwDecodeFileObject( FileObject, &FsContext, &Icb )) != NW_NTC_ICB ) { DebugTrace(-1, Dbg, "NwFastQueryStandardInfo -> FALSE\n", 0 ); return FALSE; } Fcb = Icb->SuperType.Fcb; NwAcquireExclusiveFcb( Fcb->NonPagedFcb, TRUE ); //
// If we don't have the info handy, we can't use the fast path.
//
if ( !FlagOn( Fcb->Flags, FCB_FLAGS_ATTRIBUTES_ARE_VALID ) ) { NwReleaseFcb( Fcb->NonPagedFcb ); return( FALSE ); } //
// Set the various fields in the record
//
Buffer->CreationTime = NwDateTimeToNtTime( Fcb->CreationDate, Fcb->CreationTime ); Buffer->LastAccessTime = NwDateTimeToNtTime( Fcb->LastAccessDate, DEFAULT_TIME ); Buffer->LastWriteTime = NwDateTimeToNtTime( Fcb->LastModifiedDate, Fcb->LastModifiedTime ); Buffer->ChangeTime.QuadPart = 0;
DebugTrace(0, Dbg, "QueryBasic known %wZ\n", &Fcb->RelativeFileName); DebugTrace(0, Dbg, "LastModifiedDate %x\n", Fcb->LastModifiedDate); DebugTrace(0, Dbg, "LastModifiedTime %x\n", Fcb->LastModifiedTime); DebugTrace(0, Dbg, "CreationDate %x\n", Fcb->CreationDate ); DebugTrace(0, Dbg, "CreationTime %x\n", Fcb->CreationTime ); DebugTrace(0, Dbg, "LastAccessDate %x\n", Fcb->LastAccessDate ); Buffer->FileAttributes = Fcb->NonPagedFcb->Attributes; if ( Buffer->FileAttributes == 0 ) { Buffer->FileAttributes = FILE_ATTRIBUTE_NORMAL; } IoStatus->Status = STATUS_SUCCESS; IoStatus->Information = sizeof( *Buffer ); NwReleaseFcb( Fcb->NonPagedFcb ); return TRUE; } finally { FsRtlExitFileSystem(); }}#endif
NTSTATUSNwQueryStandardInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_STANDARD_INFORMATION Buffer )
/*++
Routine Description:
This routine perforNw the query standard information operation.
Arguments:
Fcb - Supplies the FCB of the being queried
Buffer - Supplies a pointer to the buffer where the information is to be returned
Return Value:
VOID
--*/
{ NTSTATUS Status; PFCB Fcb; ULONG FileSize; BOOLEAN FirstTime = TRUE;
PAGED_CODE();
Fcb = Icb->SuperType.Fcb;
//
// Zero out the buffer.
//
RtlZeroMemory( Buffer, sizeof(FILE_STANDARD_INFORMATION) );
//
// Fill in the answers we already know.
//
Buffer->NumberOfLinks = 1;
Buffer->DeletePending = (BOOLEAN)FlagOn( Fcb->Flags, FCB_FLAGS_DELETE_ON_CLOSE );
if ( Fcb->NodeTypeCode == NW_NTC_FCB ) { Buffer->Directory = FALSE; } else { Buffer->Directory = TRUE; }
if ( !Icb->HasRemoteHandle ) {
//
// It is ok to attempt a reconnect if this request fails with a
// connection error.
//
SetFlag( IrpContext->Flags, IRP_FLAG_RECONNECTABLE );
if ( Fcb->NodeTypeCode == NW_NTC_DCB || FlagOn( Fcb->Vcb->Flags, VCB_FLAG_PRINT_QUEUE ) ) {
//
// Allow 'cd \' to work.
//
Buffer->AllocationSize.QuadPart = 0; Buffer->EndOfFile.QuadPart = 0;
return STATUS_SUCCESS;
} else {
//
// No open handle for this file. Use a path based NCP
// to get the file size.
//
Retry: IrpContext->pNpScb = Fcb->Scb->pNpScb;
if ( !BooleanFlagOn( Icb->SuperType.Fcb->Flags, FCB_FLAGS_LONG_NAME ) ) {
Status = ExchangeWithWait ( IrpContext, SynchronousResponseCallback, "FwbbJ", NCP_SEARCH_FILE, -1, Fcb->Vcb->Specific.Disk.Handle, SEARCH_ALL_FILES, &Fcb->RelativeFileName );
if ( NT_SUCCESS( Status ) ) { Status = ParseResponse( IrpContext, IrpContext->rsp, IrpContext->ResponseLength, "N_d", 20, &FileSize ); }
} else {
Status = ExchangeWithWait ( IrpContext, SynchronousResponseCallback, "LbbWDbDbC", NCP_LFN_GET_INFO, Fcb->Vcb->Specific.Disk.LongNameSpace, Fcb->Vcb->Specific.Disk.LongNameSpace, SEARCH_ALL_FILES, LFN_FLAG_INFO_FILE_SIZE, Fcb->Vcb->Specific.Disk.VolumeNumber, Fcb->Vcb->Specific.Disk.Handle, 0, &Fcb->RelativeFileName );
if ( NT_SUCCESS( Status ) ) { Status = ParseResponse( IrpContext, IrpContext->rsp, IrpContext->ResponseLength, "N_e", 10, &FileSize ); }
}
if ((Status == STATUS_INVALID_HANDLE) && (FirstTime)) {
//
// Check to see if Volume handle is invalid. Caused when volume
// is unmounted and then remounted.
//
FirstTime = FALSE;
NwReopenVcbHandle( IrpContext, Fcb->Vcb );
goto Retry; }
Buffer->AllocationSize.QuadPart = FileSize; Buffer->EndOfFile.QuadPart = FileSize;
}
} else {
//
// Start a Get file size NCP
//
IrpContext->pNpScb = Fcb->Scb->pNpScb;
if ( Fcb->NodeTypeCode == NW_NTC_FCB ) { AcquireFcbAndFlushCache( IrpContext, Fcb->NonPagedFcb ); }
Status = ExchangeWithWait( IrpContext, SynchronousResponseCallback, "F-r", NCP_GET_FILE_SIZE, &Icb->Handle, sizeof(Icb->Handle ) );
if ( NT_SUCCESS( Status ) ) { //
// Get the data from the response.
//
Status = ParseResponse( IrpContext, IrpContext->rsp, IrpContext->ResponseLength, "Nd", &FileSize );
}
if ( NT_SUCCESS( Status ) ) {
//
// Fill in Allocation size and EOF, based on the response.
//
Buffer->AllocationSize.QuadPart = FileSize; Buffer->EndOfFile.QuadPart = Buffer->AllocationSize.QuadPart;
} }
return( Status );}
#if NWFASTIO
BOOLEANNwFastQueryStandardInfo ( IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, IN OUT PFILE_STANDARD_INFORMATION Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject )/*++
Routine Description:
This routine is for the fast query call for standard file information.
Arguments:
FileObject - Supplies the file object used in this operation
Wait - Indicates if we are allowed to wait for the information
Buffer - Supplies the output buffer to receive the basic information
IoStatus - Receives the final status of the operation
Return Value:
BOOLEAN - TRUE if the operation succeeded and FALSE if the caller needs to take the long route.
--*/{ NODE_TYPE_CODE NodeTypeCode; PICB Icb; PFCB Fcb; PVOID FsContext;
//
// Find out who are.
//
try { FsRtlEnterFileSystem();
if ((NodeTypeCode = NwDecodeFileObject( FileObject, &FsContext, &Icb )) != NW_NTC_ICB ) { DebugTrace(-1, Dbg, "NwFastQueryStandardInfo -> FALSE\n", 0 ); return FALSE; } Fcb = Icb->SuperType.Fcb; //
// If we have the info handy, we can use the fast path.
//
if ( Fcb->NodeTypeCode == NW_NTC_DCB || FlagOn( Fcb->Vcb->Flags, VCB_FLAG_PRINT_QUEUE ) ) { Buffer->AllocationSize.QuadPart = 0; Buffer->EndOfFile.QuadPart = 0; Buffer->NumberOfLinks = 1; Buffer->DeletePending = (BOOLEAN)FlagOn( Fcb->Flags, FCB_FLAGS_DELETE_ON_CLOSE ); Buffer->Directory = TRUE; IoStatus->Status = STATUS_SUCCESS; IoStatus->Information = sizeof( *Buffer ); return TRUE; } else { return FALSE; } } finally {
FsRtlExitFileSystem(); }}#endif
NTSTATUSNwQueryInternalInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_INTERNAL_INFORMATION Buffer )
/*++
Routine Description:
This routine perforNw the query internal information operation.
Arguments:
Fcb - Supplies the FCB of the being queried.
Buffer - Supplies a pointer to the buffer where the information is to be returned.
Return Value:
VOID
--*/
{ PAGED_CODE();
DebugTrace(0, Dbg, "QueryInternalInfo...\n", 0);
//
// Zero out the buffer.
//
RtlZeroMemory( Buffer, sizeof(FILE_INTERNAL_INFORMATION) );
//
// Set the internal index number to be the address of the ICB.
//
Buffer->IndexNumber.HighPart = 0; Buffer->IndexNumber.QuadPart = (ULONG_PTR)Icb->NpFcb;
return( STATUS_SUCCESS );}
NTSTATUSNwQueryEaInfo ( IN PIRP_CONTEXT IrpContext, IN PFILE_EA_INFORMATION Buffer )
/*++
Routine Description:
This routine performs the query Ea information operation.
Arguments:
Buffer - Supplies a pointer to the buffer where the information is to be returned
Return Value:
VOID - The result of this query
--*/
{ PAGED_CODE();
DebugTrace(0, Dbg, "QueryEaInfo...\n", 0);
//
// Zero out the buffer.
//
RtlZeroMemory(Buffer, sizeof(FILE_EA_INFORMATION));
return STATUS_SUCCESS;}
NTSTATUSNwQueryNameInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_NAME_INFORMATION Buffer, IN PULONG Length )
/*++
Routine Description:
This routine performs the query name information operation.
Arguments:
Fcb - Supplies the FCB of the file to query.
Buffer - Supplies a pointer to the buffer where the information is to be returned
Length - Supplies and receives the length of the buffer in bytes.
Return Value:
NTSTATUS - The result of this query.
--*/
{ ULONG bytesToCopy; ULONG fileNameSize; PFCB Fcb = Icb->SuperType.Fcb;
NTSTATUS status;
PAGED_CODE();
DebugTrace(0, Dbg, "QueryNameInfo...\n", 0);
//
// Win32 expects the root directory name to be '\' terminated,
// the netware server does not. So if this is a root directory,
// (i.e RelativeFileName length is 0) append a '\' to the path name.
//
//
// See if the buffer is large enough, and decide how many bytes to copy.
//
*Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName[0] );
fileNameSize = Fcb->FullFileName.Length; if ( Fcb->RelativeFileName.Length == 0 ) { fileNameSize += sizeof(L'\\'); } Buffer->FileNameLength = fileNameSize;
if ( *Length >= fileNameSize ) {
status = STATUS_SUCCESS;
bytesToCopy = fileNameSize;
} else {
status = STATUS_BUFFER_OVERFLOW;
bytesToCopy = *Length; }
//
// Copy over the file name and its length.
//
RtlMoveMemory( Buffer->FileName, Fcb->FullFileName.Buffer, bytesToCopy);
//
// If this is a root directory, and there is space in the buffer
// append a '\' to make win32 happy.
//
if ( Fcb->RelativeFileName.Length == 0 && status == STATUS_SUCCESS ) { Buffer->FileName[ fileNameSize/sizeof(WCHAR) - 1 ] = L'\\'; }
*Length -= bytesToCopy;
return status;}
NTSTATUSNwQueryAltNameInfo ( IN PIRP_CONTEXT pIrpContext, IN PICB Icb, IN PFILE_NAME_INFORMATION Buffer, IN PULONG Length )
/*++
Routine Description:
This routine performs the AltName query name information operation.
Arguments:
Fcb - Supplies the FCB of the file to query.
Buffer - Supplies a pointer to the buffer where the information is to be returned
Length - Supplies and receives the length of the buffer in bytes.
Return Value:
NTSTATUS - The result of this query.
--*/
{ ULONG bytesToCopy; ULONG fileNameSize; PFCB Fcb = Icb->SuperType.Fcb;
UNICODE_STRING ShortName; NTSTATUS status;
PAGED_CODE();
DebugTrace(0, Dbg, "QueryAltNameInfo...\n", 0);
pIrpContext->pNpScb = Fcb->Scb->pNpScb;
//
// See if the buffer is large enough, and decide how many bytes to copy.
//
*Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName[0] );
ShortName.MaximumLength = MAX_PATH; ShortName.Buffer=NULL; ShortName.Length = 0;
status = ExchangeWithWait ( pIrpContext, SynchronousResponseCallback, "LbbWDbDbC", NCP_LFN_GET_INFO, Fcb->Vcb->Specific.Disk.LongNameSpace, 0x0, //0x0 DOS Nam
SEARCH_ALL_DIRECTORIES, LFN_FLAG_INFO_NAME, Fcb->Vcb->Specific.Disk.VolumeNumber, Fcb->Vcb->Specific.Disk.Handle, 0, &Fcb->RelativeFileName );
if (!NT_SUCCESS( status ) ){ return status; }
ShortName.Buffer= ALLOCATE_POOL(NonPagedPool, ShortName.MaximumLength+sizeof(WCHAR)); if (ShortName.Buffer == NULL){ return STATUS_INSUFFICIENT_RESOURCES; }
status = ParseResponse( pIrpContext, pIrpContext->rsp, pIrpContext->ResponseLength, "N_P", 76, &ShortName);
if ( NT_SUCCESS( status ) ) {
fileNameSize = ShortName.Length;
if ( *Length >= fileNameSize ) {
status = STATUS_SUCCESS; bytesToCopy = fileNameSize;
} else {
status = STATUS_BUFFER_OVERFLOW; bytesToCopy = *Length; }
Buffer->FileNameLength = fileNameSize;
RtlMoveMemory( Buffer->FileName, ShortName.Buffer, bytesToCopy);
*Length -= bytesToCopy;
}
FREE_POOL(ShortName.Buffer);
return status;}
NTSTATUSNwQueryPositionInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_POSITION_INFORMATION Buffer )
/*++
Routine Description:
This routine performs the query position information operation.
Arguments:
Fcb - Supplies the FCB of the file being queried.
Buffer - Supplies a pointer to the buffer where the information is to be returned.
Return Value:
VOID
--*/
{ PAGED_CODE();
DebugTrace(0, Dbg, "QueryPositionInfo...\n", 0);
//
// Return the current byte offset. This info is totally
// bogus for asynchronous files. Also note that we don't
// use the FilePosition member of the ICB for anything.
//
if ( Icb->FileObject ) { Buffer->CurrentByteOffset.QuadPart = Icb->FileObject->CurrentByteOffset.QuadPart; }
return STATUS_SUCCESS;}
NTSTATUSNwSetBasicInfo ( IN PIRP_CONTEXT pIrpContext, IN PICB Icb, IN PFILE_BASIC_INFORMATION Buffer )/*++
Routine Description:
This routine sets the basic information for a file.
Arguments:
pIrpContext - Supplies Irp context information.
Icb - Supplies the ICB for the file being modified.
Buffer - Supplies the buffer containing the data being set.
Return Value:
NTSTATUS - Returns our completion status.
--*/
{ PFCB Fcb; NTSTATUS Status; BOOLEAN SetTime = FALSE; BOOLEAN SetAttributes = FALSE; ULONG LfnFlag = 0;
PAGED_CODE();
DebugTrace(0, Dbg, "SetBasicInfo...\n", 0);
Fcb = Icb->SuperType.Fcb;
pIrpContext->pNpScb = Fcb->Scb->pNpScb;
//
// Append this IRP context and wait to get to the front.
// then grab from FCB
//
NwAppendToQueueAndWait( pIrpContext ); NwAcquireExclusiveFcb( Fcb->NonPagedFcb, TRUE );
//
// It is ok to attempt a reconnect if this request fails with a
// connection error.
//
SetFlag( pIrpContext->Flags, IRP_FLAG_RECONNECTABLE );
if (Buffer->CreationTime.QuadPart != 0) {
//
// Modify the creation time.
//
Status = NwNtTimeToNwDateTime( Buffer->CreationTime, &Fcb->CreationDate, &Fcb->CreationTime );
if ( !NT_SUCCESS( Status ) ) { NwReleaseFcb( Fcb->NonPagedFcb ); return( Status ); }
SetTime = TRUE; LfnFlag |= LFN_FLAG_SET_INFO_CREATE_DATE | LFN_FLAG_SET_INFO_CREATE_TIME; }
if (Buffer->LastAccessTime.QuadPart != 0) {
USHORT Dummy;
//
// Modify the last access time.
//
Status = NwNtTimeToNwDateTime( Buffer->LastAccessTime, &Fcb->LastAccessDate, &Dummy );
if ( !NT_SUCCESS( Status ) ) { NwReleaseFcb( Fcb->NonPagedFcb ); return( Status ); }
SetTime = TRUE; LfnFlag |= LFN_FLAG_SET_INFO_LASTACCESS_DATE;
// Set the last access flag in the ICB so that we update
// last access time for real when we close this handle!
Icb->UserSetLastAccessTime = TRUE; }
if (Buffer->LastWriteTime.QuadPart != 0) {
//
// Modify the last write time
//
Status = NwNtTimeToNwDateTime( Buffer->LastWriteTime, &Fcb->LastModifiedDate, &Fcb->LastModifiedTime );
if ( !NT_SUCCESS( Status ) ) { NwReleaseFcb( Fcb->NonPagedFcb ); return( Status ); }
LfnFlag |= LFN_FLAG_SET_INFO_MODIFY_DATE | LFN_FLAG_SET_INFO_MODIFY_TIME; }
if (Buffer->FileAttributes != 0) { LfnFlag |= LFN_FLAG_SET_INFO_ATTRIBUTES; }
if ( LfnFlag == 0 ) {
//
// Nothing to set, simply return success.
//
Status = STATUS_SUCCESS; }
if ( Fcb->NodeTypeCode == NW_NTC_FCB ) {
//
// Call plain FlushCache - we don't want to acquire and
// release the NpFcb. We are already at the front and have the Fcb
// exclusive.
//
FlushCache( pIrpContext, Fcb->NonPagedFcb ); }
if ( BooleanFlagOn( Fcb->Flags, FCB_FLAGS_LONG_NAME ) ) {
Status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "LbbWDW--WW==WW==_W_bDbC", NCP_LFN_SET_INFO, Fcb->Vcb->Specific.Disk.LongNameSpace, Fcb->Vcb->Specific.Disk.LongNameSpace, Fcb->NodeTypeCode == NW_NTC_FCB ? SEARCH_ALL_FILES : SEARCH_ALL_DIRECTORIES, LfnFlag, NtAttributesToNwAttributes( Buffer->FileAttributes ), Fcb->CreationDate, Fcb->CreationTime, Fcb->LastModifiedDate, Fcb->LastModifiedTime, 8, Fcb->LastAccessDate, 8, Fcb->Vcb->Specific.Disk.VolumeNumber, Fcb->Vcb->Specific.Disk.Handle, 0, &Fcb->RelativeFileName );
} else {
if ( LfnFlag & LFN_FLAG_SET_INFO_ATTRIBUTES ) { Status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "FbbbU", NCP_SET_FILE_ATTRIBUTES, NtAttributesToNwAttributes( Buffer->FileAttributes ), Fcb->Vcb->Specific.Disk.Handle, Fcb->NodeTypeCode == NW_NTC_FCB ? SEARCH_ALL_FILES : SEARCH_ALL_DIRECTORIES, &Fcb->RelativeFileName );
if ( !NT_SUCCESS( Status ) ) { NwReleaseFcb( Fcb->NonPagedFcb ); return( Status ); }
}
#if 0
//
// We could conceivably use ScanDir/SetDir to update last access
// and create time. Not supported yet.
//
if ( LfnFlag & ( LFN_FLAG_SET_INFO_LASTACCESS_DATE | LFN_FLAG_SET_INFO_CREATE_DATE ) ) {
ULONG SearchIndex; ULONG Directory;
Status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "SbbdU", 0x16, 0x1E, // Scan dir entry
Fcb->Vcb->Specific.Disk.Handle, 0x06, // Search attributes
-1, // Search index
&Fcb->RelativeFileName );
if ( NT_SUCCESS( Status ) ) { Status = ParseResponse( pIrpContext, pIrpContext->rsp, pIrpContext->ResponseLength, "Ndd", &SearchIndex, &Directory ); }
if ( NT_SUCCESS( Status ) ) { Status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "Sbbdddw=----_ww==ww==ww", 0x16, 0x25, // Set dir entry
Fcb->Vcb->Specific.Disk.Handle, 0x06, // Search attributes
SearchIndex, 0, // Change Bits?
Directory, 12, Fcb->CreationDate, 0, Fcb->LastAccessDate, 0, Fcb->LastModifiedDate, Fcb->LastModifiedTime ); } }#endif
if ( LfnFlag & LFN_FLAG_SET_INFO_MODIFY_DATE ) { Status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "F-rww-", NCP_SET_FILE_TIME, &Icb->Handle, sizeof( Icb->Handle ), Fcb->LastModifiedTime, Fcb->LastModifiedDate ); } }
NwReleaseFcb( Fcb->NonPagedFcb );
//
// And return to our caller
//
return Status;}
NTSTATUSNwSetDispositionInfo ( IN PIRP_CONTEXT pIrpContext, IN PICB Icb, IN PFILE_DISPOSITION_INFORMATION Buffer )/*++
Routine Description:
This routine sets the disposition information for a file.
Arguments:
pIrpContext - Supplies Irp context information.
Icb - Supplies the ICB for the file being modified.
Buffer - Supplies the buffer containing the data being set.
Return Value:
NTSTATUS - Returns our completion status.
--*/{ PFCB Fcb; NTSTATUS Status;
PAGED_CODE();
DebugTrace(0, Dbg, "SetDispositionInfo...\n", 0);
Fcb = Icb->SuperType.Fcb;
if ( FlagOn( Fcb->Vcb->Flags, VCB_FLAG_PRINT_QUEUE ) ) {
//
// This is a print queue, just pretend this IRP succeeded.
//
Status = STATUS_SUCCESS;
} else {
//
// This is a real file or directory. Mark it delete pending.
//
SetFlag( Fcb->Flags, FCB_FLAGS_DELETE_ON_CLOSE );
pIrpContext->pNpScb = Fcb->Scb->pNpScb; pIrpContext->Icb = Icb;
Icb->State = ICB_STATE_CLOSE_PENDING;
//
// Go ahead, delete the file.
//
Status = NwDeleteFile( pIrpContext ); }
return( Status );}
NTSTATUSNwDeleteFile( PIRP_CONTEXT pIrpContext )/*++
Routine Description:
This routine continues processing of the SetDispositionInfo request. It must run in the redirector FSP.
Arguments:
pIrpContext - A pointer to the IRP context information for the request in progress.
Return Value:
The status of the operation.
--*/{ PICB Icb; PFCB Fcb; NTSTATUS Status;
PAGED_CODE();
Icb = pIrpContext->Icb; Fcb = Icb->SuperType.Fcb;
ClearFlag( Fcb->Flags, FCB_FLAGS_DELETE_ON_CLOSE );
//
// To a delete a file, first close the remote handle.
//
if ( Icb->HasRemoteHandle ) {
Icb->HasRemoteHandle = FALSE;
Status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "F-r", NCP_CLOSE, Icb->Handle, sizeof( Icb->Handle ) ); }
//
// Note that this request cannot be reconnectable since, it can
// be called via NwCloseIcb(). See comment in that routine for
// more info.
//
if ( Fcb->NodeTypeCode == NW_NTC_FCB ) {
if ( !BooleanFlagOn( Fcb->Flags, FCB_FLAGS_LONG_NAME ) ) {
Status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "FbbJ", NCP_DELETE_FILE, Fcb->Vcb->Specific.Disk.Handle, SEARCH_ALL_FILES, &Fcb->RelativeFileName );
} else {
Status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "LbbW-DbC", NCP_LFN_DELETE_FILE, Fcb->Vcb->Specific.Disk.LongNameSpace, Fcb->Vcb->Specific.Disk.VolumeNumber, NW_ATTRIBUTE_SYSTEM | NW_ATTRIBUTE_HIDDEN, Fcb->Vcb->Specific.Disk.Handle, LFN_FLAG_SHORT_DIRECTORY, &Fcb->RelativeFileName ); }
} else {
ASSERT( Fcb->NodeTypeCode == NW_NTC_DCB );
if ( !BooleanFlagOn( Fcb->Flags, FCB_FLAGS_LONG_NAME ) ) {
Status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "SbbJ", NCP_DIR_FUNCTION, NCP_DELETE_DIRECTORY, Fcb->Vcb->Specific.Disk.Handle, SEARCH_ALL_DIRECTORIES, &Fcb->RelativeFileName ); } else {
Status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "LbbW-DbC", NCP_LFN_DELETE_FILE, Fcb->Vcb->Specific.Disk.LongNameSpace, Fcb->Vcb->Specific.Disk.VolumeNumber, SEARCH_ALL_DIRECTORIES, Fcb->Vcb->Specific.Disk.Handle, LFN_FLAG_SHORT_DIRECTORY, &Fcb->RelativeFileName ); }
}
if ( NT_SUCCESS( Status )) {
Status = ParseResponse( pIrpContext, pIrpContext->rsp, pIrpContext->ResponseLength, "N" );
} else {
//
// We can map all failures to STATUS_NO_SUCH_FILE
// except ACCESS_DENIED, which happens with a read
// only file.
//
if ( Status != STATUS_ACCESS_DENIED ) { Status = STATUS_NO_SUCH_FILE; }
}
return Status;}
NTSTATUSNwSetRenameInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_RENAME_INFORMATION Buffer )/*++
Routine Description:
This routine set rename information for a file.
Arguments:
pIrpContext - A pointer to the IRP context information for the request in progress.
Icb - A pointer to the ICB of the file to set.
Buffer - The request buffer.
Return Value:
The status of the operation.
--*/{ PIRP Irp; PIO_STACK_LOCATION irpSp; NTSTATUS Status; NTSTATUS Status2; PFCB Fcb; PFCB TargetFcb; BOOLEAN HandleAllocated = FALSE; BYTE Handle; PICB TargetIcb = NULL;
UNICODE_STRING OldDrive; UNICODE_STRING OldServer; UNICODE_STRING OldVolume; UNICODE_STRING OldPath; UNICODE_STRING OldFileName; UNICODE_STRING OldFullName; WCHAR OldDriveLetter; UNICODE_STRING OldFcbFullName;
UNICODE_STRING NewDrive; UNICODE_STRING NewServer; UNICODE_STRING NewVolume; UNICODE_STRING NewPath; UNICODE_STRING NewFileName; UNICODE_STRING NewFullName; WCHAR NewDriveLetter; UNICODE_STRING NewFcbFullName;
USHORT i;
PAGED_CODE();
DebugTrace(+1, Dbg, "SetRenameInfo...\n", 0);
//
// Can't try to set rename info on a print queue.
//
Fcb = Icb->SuperType.Fcb;
if ( FlagOn( Fcb->Vcb->Flags, VCB_FLAG_PRINT_QUEUE ) ) { return( STATUS_INVALID_PARAMETER ); }
//
// It is ok to attempt a reconnect if this request fails with a
// connection error.
//
SetFlag( IrpContext->Flags, IRP_FLAG_RECONNECTABLE );
//
// Get the current stack location.
//
Irp = IrpContext->pOriginalIrp; irpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace( 0, Dbg, " ->FullFileName = %wZ\n", &Fcb->FullFileName);
if (irpSp->Parameters.SetFile.FileObject != NULL) {
TargetIcb = irpSp->Parameters.SetFile.FileObject->FsContext2;
DebugTrace( 0, Dbg, " ->FullFileName = %wZ\n", &TargetIcb->SuperType.Fcb->FullFileName);
if ( TargetIcb->SuperType.Fcb->Scb != Icb->SuperType.Fcb->Scb ) { return STATUS_NOT_SAME_DEVICE; }
} else {
DebugTrace( 0, Dbg, " ->FullFileName in users buffer\n", 0); DebugTrace(-1, Dbg, "SetRenameInfo %08lx\n", STATUS_NOT_IMPLEMENTED); return STATUS_NOT_IMPLEMENTED; }
DebugTrace( 0, Dbg, " ->TargetFileName = %wZ\n", &irpSp->Parameters.SetFile.FileObject->FileName);
TargetFcb = ((PNONPAGED_FCB)irpSp->Parameters.SetFile.FileObject->FsContext)->Fcb;
IrpContext->pNpScb = Fcb->Scb->pNpScb;
NwAppendToQueueAndWait( IrpContext ); NwAcquireExclusiveFcb( Fcb->NonPagedFcb, TRUE );
try {
//
// If either source or destination is a long name, use
// the long name path.
//
if ( !BooleanFlagOn( Fcb->Flags, FCB_FLAGS_LONG_NAME ) && IsFatNameValid( &TargetFcb->RelativeFileName ) && !BooleanFlagOn( Fcb->Vcb->Flags, VCB_FLAG_LONG_NAME ) ) {
//
// Strip to UID portion of the FCB name.
//
for ( i = 0 ; i < Fcb->FullFileName.Length / sizeof(WCHAR) ; i++ ) { if ( Fcb->FullFileName.Buffer[i] == OBJ_NAME_PATH_SEPARATOR ) { break; } }
ASSERT( Fcb->FullFileName.Buffer[i] == OBJ_NAME_PATH_SEPARATOR );
OldFcbFullName.Length = Fcb->FullFileName.Length - i*sizeof(WCHAR); OldFcbFullName.Buffer = Fcb->FullFileName.Buffer + i;
Status = CrackPath ( &OldFcbFullName, &OldDrive, &OldDriveLetter, &OldServer, &OldVolume, &OldPath, &OldFileName, &OldFullName );
ASSERT(NT_SUCCESS(Status));
//
// Strip to UID portion of the FCB name.
//
TargetFcb = ((PNONPAGED_FCB)(irpSp->Parameters.SetFile.FileObject->FsContext))->Fcb;
for ( i = 0 ; i < TargetFcb->FullFileName.Length / sizeof(WCHAR) ; i++ ) { if ( TargetFcb->FullFileName.Buffer[i] == OBJ_NAME_PATH_SEPARATOR ) { break; } }
ASSERT( TargetFcb->FullFileName.Buffer[i] == OBJ_NAME_PATH_SEPARATOR );
NewFcbFullName.Length = TargetFcb->FullFileName.Length - i*sizeof(WCHAR); NewFcbFullName.Buffer = TargetFcb->FullFileName.Buffer + i;
Status = CrackPath ( &NewFcbFullName, &NewDrive, &NewDriveLetter, &NewServer, &NewVolume, &NewPath, &NewFileName, &NewFullName );
ASSERT(NT_SUCCESS(Status));
//
// Make sure that this is the same volume.
//
if ( RtlCompareUnicodeString( &NewVolume, &OldVolume, TRUE ) != 0 ) { try_return( Status = STATUS_NOT_SAME_DEVICE ); }
if (Icb->SuperType.Fcb->IcbCount != 1) { try_return( Status = STATUS_ACCESS_DENIED ); }
//
// After a rename, the only operation allowed on the handle is an
// NtClose.
//
Icb->State = ICB_STATE_CLOSE_PENDING;
if ((irpSp->Parameters.SetFile.ReplaceIfExists ) && (TargetIcb->Exists)) {
// Delete the file
Status2 = ExchangeWithWait( IrpContext, SynchronousResponseCallback, "Fb-J", NCP_DELETE_FILE, TargetFcb->Vcb->Specific.Disk.Handle, &TargetFcb->RelativeFileName );
#ifdef NWDBG
if ( NT_SUCCESS( Status2 ) ) { Status2 = ParseResponse( IrpContext, IrpContext->rsp, IrpContext->ResponseLength, "N" ); }
ASSERT(NT_SUCCESS(Status2));#endif
}
//
// Need to create a handle to the directory containing the old
// file/directory name because directory rename does not contain a
// path and there might not be room for two paths in a file rename.
//
// The way we do this is to allocate a temporary handle on the server.
// This request is at the front of the Scb->Requests queue and so can
// use the temporary handle and delete it without affecting any other
// requests.
//
if ( OldPath.Length == 0 ) {
// In the root so use the VCB handle.
Handle = Fcb->Vcb->Specific.Disk.Handle;
} else {
Status = ExchangeWithWait ( IrpContext, SynchronousResponseCallback, "SbbJ", // NCP Allocate temporary directory handle
NCP_DIR_FUNCTION, NCP_ALLOCATE_TEMP_DIR_HANDLE, Fcb->Vcb->Specific.Disk.Handle, '[', &OldPath );
if ( NT_SUCCESS( Status ) ) { Status = ParseResponse( IrpContext, IrpContext->rsp, IrpContext->ResponseLength, "Nb", &Handle ); }
if (!NT_SUCCESS(Status)) { try_return(Status); }
HandleAllocated = TRUE; }
if ( Fcb->NodeTypeCode == NW_NTC_DCB ) {
//
// We can only rename files in the same directory
//
if ( RtlCompareUnicodeString( &NewPath, &OldPath, TRUE ) != 0 ) { try_return(Status = STATUS_NOT_SUPPORTED);
} else {
Status = ExchangeWithWait ( IrpContext, SynchronousResponseCallback, "SbJJ", NCP_DIR_FUNCTION, NCP_RENAME_DIRECTORY, Handle, &OldFileName, &NewFileName); }
} else {
//
// We have to close the handle associated with the Icb that
// is doing the rename. Close that handle or the rename will
// fail for sure.
//
if ( Icb->HasRemoteHandle ) {
Status2 = ExchangeWithWait( IrpContext, SynchronousResponseCallback, "F-r", NCP_CLOSE, Icb->Handle, sizeof( Icb->Handle ) );
Icb->HasRemoteHandle = FALSE;
#ifdef NWDBG
if ( NT_SUCCESS( Status2 ) ) { Status2 = ParseResponse( IrpContext, IrpContext->rsp, IrpContext->ResponseLength, "N" ); }
ASSERT(NT_SUCCESS(Status2));#endif
}
//
// Do the file rename Ncp.
//
Status = ExchangeWithWait ( IrpContext, SynchronousResponseCallback, "FbbJbJ", NCP_RENAME_FILE, Handle, SEARCH_ALL_FILES, &OldFileName, Fcb->Vcb->Specific.Disk.Handle, &NewFullName); }
} else {
//
// We are going through the long name path. Ensure that the
// VCB supports long names.
//
if ( Icb->SuperType.Fcb->Vcb->Specific.Disk.LongNameSpace == LFN_NO_OS2_NAME_SPACE) { try_return( Status = STATUS_OBJECT_PATH_SYNTAX_BAD ); }
if (Icb->SuperType.Fcb->IcbCount != 1) { try_return( Status = STATUS_ACCESS_DENIED); }
//
// After a rename, the only operation allowed on the handle is an
// NtClose.
//
Icb->State = ICB_STATE_CLOSE_PENDING;
if ((irpSp->Parameters.SetFile.ReplaceIfExists ) && (TargetIcb->Exists)) {
// Delete the file
Status = ExchangeWithWait( IrpContext, SynchronousResponseCallback, "LbbW-DbC", NCP_LFN_DELETE_FILE, TargetFcb->Vcb->Specific.Disk.LongNameSpace, TargetFcb->Vcb->Specific.Disk.VolumeNumber, SEARCH_ALL_FILES, TargetFcb->Vcb->Specific.Disk.Handle, LFN_FLAG_SHORT_DIRECTORY, &TargetFcb->RelativeFileName );
#ifdef NWDBG
if ( NT_SUCCESS( Status ) ) { Status2 = ParseResponse( IrpContext, IrpContext->rsp, IrpContext->ResponseLength, "N" ); }
ASSERT(NT_SUCCESS(Status2));#endif
}
if ( Fcb->NodeTypeCode == NW_NTC_DCB ) {
//
// We can only rename files in the same directory
//
if ( Fcb->Vcb != TargetFcb->Vcb ) { try_return(Status = STATUS_NOT_SUPPORTED);
} else {
Status = ExchangeWithWait ( IrpContext, SynchronousResponseCallback, "LbbWbDbbbDbbNN", NCP_LFN_RENAME_FILE, Fcb->Vcb->Specific.Disk.LongNameSpace, 0, // Rename flag
SEARCH_ALL_DIRECTORIES, Fcb->Vcb->Specific.Disk.VolumeNumber, Fcb->Vcb->Specific.Disk.Handle, LFN_FLAG_SHORT_DIRECTORY, OccurenceCount( &Fcb->RelativeFileName, OBJ_NAME_PATH_SEPARATOR ) + 1, Fcb->Vcb->Specific.Disk.VolumeNumber, Fcb->Vcb->Specific.Disk.Handle, LFN_FLAG_SHORT_DIRECTORY, OccurenceCount( &TargetFcb->RelativeFileName, OBJ_NAME_PATH_SEPARATOR ) + 1, &Fcb->RelativeFileName, &TargetFcb->RelativeFileName ); }
} else {
//
// We have to close the handle associated with the Icb that
// is doing the rename. Close that handle or the rename will
// fail for sure.
//
if ( Icb->HasRemoteHandle ) {
Status2 = ExchangeWithWait( IrpContext, SynchronousResponseCallback, "F-r", NCP_CLOSE, Icb->Handle, sizeof( Icb->Handle ) );
Icb->HasRemoteHandle = FALSE;
#ifdef NWDBG
if ( NT_SUCCESS( Status2 ) ) { Status2 = ParseResponse( IrpContext, IrpContext->rsp, IrpContext->ResponseLength, "N" ); }
ASSERT(NT_SUCCESS(Status2));#endif
}
//
// Do the file rename Ncp.
//
Status = ExchangeWithWait ( IrpContext, SynchronousResponseCallback, "LbbWbDbbbDbbNN", NCP_LFN_RENAME_FILE, Fcb->Vcb->Specific.Disk.LongNameSpace, 0, // Rename flag
SEARCH_ALL_FILES, Fcb->Vcb->Specific.Disk.VolumeNumber, Fcb->Vcb->Specific.Disk.Handle, LFN_FLAG_SHORT_DIRECTORY, OccurenceCount( &Fcb->RelativeFileName, OBJ_NAME_PATH_SEPARATOR ) + 1, Fcb->Vcb->Specific.Disk.VolumeNumber, Fcb->Vcb->Specific.Disk.Handle, LFN_FLAG_SHORT_DIRECTORY, OccurenceCount( &TargetFcb->RelativeFileName, OBJ_NAME_PATH_SEPARATOR ) + 1, &Fcb->RelativeFileName, &TargetFcb->RelativeFileName ); } }
try_exit: NOTHING; } finally {
if (HandleAllocated) {
Status2 = ExchangeWithWait ( IrpContext, SynchronousResponseCallback, "Sb", // NCP Deallocate directory handle
NCP_DIR_FUNCTION, NCP_DEALLOCATE_DIR_HANDLE, Handle);#ifdef NWDBG
if ( NT_SUCCESS( Status2 ) ) { Status2 = ParseResponse( IrpContext, IrpContext->rsp, IrpContext->ResponseLength, "N" ); }
ASSERT(NT_SUCCESS(Status2));#endif
}
NwReleaseFcb( Fcb->NonPagedFcb ); }
DebugTrace(-1, Dbg, "SetRenameInfo %08lx\n", Status );
//
// We're done with this request. Dequeue the IRP context from
// SCB and complete the request.
//
if ( Status != STATUS_PENDING ) { NwDequeueIrpContext( IrpContext, FALSE ); }
return Status;}
NTSTATUSNwSetPositionInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_POSITION_INFORMATION Buffer )/*++
Routine Description:
This routine sets position information for a file.
Arguments:
pIrpContext - A pointer to the IRP context information for the request in progress.
Icb - A pointer to the ICB of the file to set.
Buffer - The request buffer.
Return Value:
The status of the operation.
--*/{ PAGED_CODE();
ASSERT( Buffer->CurrentByteOffset.HighPart == 0 );
if ( Icb->FileObject ) { Icb->FileObject->CurrentByteOffset.QuadPart = Buffer->CurrentByteOffset.QuadPart; }
return( STATUS_SUCCESS );}
NTSTATUSNwSetAllocationInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_ALLOCATION_INFORMATION Buffer )/*++
Routine Description:
This routine sets allocation information for a file.
Arguments:
pIrpContext - A pointer to the IRP context information for the request in progress.
Icb - A pointer to the ICB of the file to set.
Buffer - The request buffer.
Return Value:
The status of the operation.
--*/{ NTSTATUS Status; PIRP irp; PIO_STACK_LOCATION irpSp; PFCB fcb = (PFCB)Icb->SuperType.Fcb; PULONG pFileSize;
PAGED_CODE();
ASSERT( Buffer->AllocationSize.HighPart == 0);
if ( fcb->NodeTypeCode == NW_NTC_FCB ) {
pFileSize = &Icb->NpFcb->Header.FileSize.LowPart;
IrpContext->pNpScb = fcb->Scb->pNpScb;
if (BooleanFlagOn( fcb->Vcb->Flags, VCB_FLAG_PRINT_QUEUE ) ) { if (IsTerminalServer()) { // 2/10/97 cjc Fix problem for binary files not printing correctly
// if done via the COPY command. Works with NT RDR so
// changed this to behave same way.
return(STATUS_INVALID_PARAMETER); } else { return STATUS_SUCCESS; } }
} else if ( fcb->NodeTypeCode == NW_NTC_SCB ) {
pFileSize = &Icb->FileSize;
IrpContext->pNpScb = ((PSCB)fcb)->pNpScb;
} else {
DebugTrace(0, Dbg, "Not a file or a server\n", 0);
DebugTrace( 0, Dbg, "NwSetAllocationInfo -> %08lx\n", STATUS_INVALID_PARAMETER ); return STATUS_INVALID_PARAMETER; }
NwAppendToQueueAndWait( IrpContext );
if ( !Icb->HasRemoteHandle ) {
Status = STATUS_INVALID_PARAMETER;
} else if ( Buffer->AllocationSize.LowPart == *pFileSize ) {
Status = STATUS_SUCCESS;
} else {
irp = IrpContext->pOriginalIrp; irpSp = IoGetCurrentIrpStackLocation( irp );
#ifndef QFE_BUILD
if ( Buffer->AllocationSize.LowPart < *pFileSize ) {
//
// Before we actually truncate, check to see if the purge
// is going to fail.
//
if (!MmCanFileBeTruncated( irpSp->FileObject->SectionObjectPointer, &Buffer->AllocationSize )) {
return( STATUS_USER_MAPPED_FILE ); } }#endif
if ( fcb->NodeTypeCode == NW_NTC_FCB ) { AcquireFcbAndFlushCache( IrpContext, fcb->NonPagedFcb ); }
Status = ExchangeWithWait( IrpContext, SynchronousResponseCallback, "F-rd=", NCP_WRITE_FILE, &Icb->Handle, sizeof( Icb->Handle ), Buffer->AllocationSize.LowPart );
if ( NT_SUCCESS( Status ) ) { *pFileSize = Buffer->AllocationSize.LowPart; } }
NwDequeueIrpContext( IrpContext, FALSE );
return( Status );}
NTSTATUSNwSetEndOfFileInfo ( IN PIRP_CONTEXT IrpContext, IN PICB Icb, IN PFILE_END_OF_FILE_INFORMATION Buffer )/*++
Routine Description:
This routine sets end of file information for a file.
Arguments:
pIrpContext - A pointer to the IRP context information for the request in progress.
Icb - A pointer to the ICB of the file to set.
Buffer - The request buffer.
Return Value:
The status of the operation.
--*/{ NTSTATUS Status; PIRP irp; PIO_STACK_LOCATION irpSp; PFCB fcb = (PFCB)Icb->SuperType.Fcb; PULONG pFileSize;
PAGED_CODE();
ASSERT( Buffer->EndOfFile.HighPart == 0);
if ( fcb->NodeTypeCode == NW_NTC_FCB ) {
pFileSize = &Icb->NpFcb->Header.FileSize.LowPart;
IrpContext->pNpScb = fcb->Scb->pNpScb;
if (BooleanFlagOn( fcb->Vcb->Flags, VCB_FLAG_PRINT_QUEUE ) ) {
return STATUS_SUCCESS;
}
} else if ( fcb->NodeTypeCode == NW_NTC_SCB ) {
pFileSize = &Icb->FileSize;
IrpContext->pNpScb = ((PSCB)fcb)->pNpScb;
} else {
DebugTrace(0, Dbg, "Not a file or a server\n", 0);
DebugTrace( 0, Dbg, "NwSetAllocationInfo -> %08lx\n", STATUS_INVALID_PARAMETER ); return STATUS_INVALID_PARAMETER; }
NwAppendToQueueAndWait( IrpContext );
if ( !Icb->HasRemoteHandle ) {
Status = STATUS_INVALID_PARAMETER;
} else if ( Buffer->EndOfFile.LowPart == *pFileSize ) {
Status = STATUS_SUCCESS;
} else {
irp = IrpContext->pOriginalIrp; irpSp = IoGetCurrentIrpStackLocation( irp );
#ifndef QFE_BUILD
if ( Buffer->EndOfFile.LowPart < *pFileSize ) {
//
// Before we actually truncate, check to see if the purge
// is going to fail.
//
if (!MmCanFileBeTruncated( irpSp->FileObject->SectionObjectPointer, &Buffer->EndOfFile )) {
return( STATUS_USER_MAPPED_FILE ); } }#endif
if ( fcb->NodeTypeCode == NW_NTC_FCB ) { AcquireFcbAndFlushCache( IrpContext, fcb->NonPagedFcb ); }
Status = ExchangeWithWait( IrpContext, SynchronousResponseCallback, "F-rd=", NCP_WRITE_FILE, &Icb->Handle, sizeof( Icb->Handle ), Buffer->EndOfFile.LowPart );
if ( NT_SUCCESS( Status ) ) { *pFileSize = Buffer->EndOfFile.LowPart; } }
NwDequeueIrpContext( IrpContext, FALSE );
return( Status );}
ULONGOccurenceCount ( IN PUNICODE_STRING String, IN WCHAR SearchChar )/*++
Routine Description:
This routine counts the number of occurences of a search character in a string
Arguments:
String - The string to search
SearchChar - The character to search for.
Return Value:
The occurence count.
--*/{ PWCH currentChar; PWCH endOfString; ULONG count = 0;
PAGED_CODE();
currentChar = String->Buffer; endOfString = &String->Buffer[ String->Length / sizeof(WCHAR) ];
while ( currentChar < endOfString ) { if ( *currentChar == SearchChar ) { count++; } currentChar++; }
return( count );}
|
