able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/rdr2/rdbss/dirctrl.c

581 lines
18 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
DirCtrl.c
Abstract:
This module implements the File Directory Control routines for Rx called
by the dispatch driver.
Author:
Joe Linn [Joe Linn] 4-oct-94
Balan Sethu Raman [SethuR] 16-Oct-95 Hook in the notify change API routines
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
//
// The local debug trace level
//
#define Dbg (DEBUG_TRACE_DIRCTRL)
WCHAR Rx8QMdot3QM[12] = { DOS_QM, DOS_QM, DOS_QM, DOS_QM, DOS_QM, DOS_QM, DOS_QM, DOS_QM,
L'.', DOS_QM, DOS_QM, DOS_QM};
WCHAR RxStarForTemplate[] = L"*";
//
// Local procedure prototypes
//
NTSTATUS
RxQueryDirectory ( RXCOMMON_SIGNATURE );
NTSTATUS
RxNotifyChangeDirectory ( RXCOMMON_SIGNATURE );
NTSTATUS
RxLowIoNotifyChangeDirectoryCompletion( RXCOMMON_SIGNATURE );
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, RxCommonDirectoryControl)
#pragma alloc_text(PAGE, RxNotifyChangeDirectory)
#pragma alloc_text(PAGE, RxQueryDirectory)
#pragma alloc_text(PAGE, RxLowIoNotifyChangeDirectoryCompletion)
#endif
NTSTATUS
RxCommonDirectoryControl ( RXCOMMON_SIGNATURE )
/*++
Routine Description:
This is the common routine for doing directory control operations called
by both the fsd and fsp threads
Arguments:
Irp - Supplies the Irp to process
Return Value:
RXSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
RxCaptureRequestPacket;
RxCaptureFcb;
RxCaptureFobx;
RxCaptureParamBlock;
PAGED_CODE();
//
// Get a pointer to the current Irp stack location
//
RxDbgTrace(+1, Dbg, ("RxCommonDirectoryControl IrpC/Fobx/Fcb = %08lx %08lx %08lx\n",
RxContext,capFobx,capFcb));
RxDbgTrace( 0, Dbg, ("MinorFunction = %08lx\n", capPARAMS->MinorFunction ));
RxLog(("CommDirC %lx %lx %lx %ld\n",RxContext,capFobx,capFcb,capPARAMS->MinorFunction));
RxWmiLog(LOG,
RxCommonDirectoryControl,
LOGPTR(RxContext)
LOGPTR(capFobx)
LOGPTR(capFcb)
LOGUCHAR(capPARAMS->MinorFunction));
// This is to fix bug 174103 in our rdpdr minirdr. As we can't determine
// the exact storage type in some cases. We'll have a real fix for Beta2.
//
//if (NodeType(capFcb) != RDBSS_NTC_STORAGE_TYPE_DIRECTORY) {
// return STATUS_NOT_SUPPORTED;
//}
//
// We know this is a directory control so we'll case on the
// minor function, and call a internal worker routine to complete
// the irp.
//
switch ( capPARAMS->MinorFunction ) {
case IRP_MN_QUERY_DIRECTORY:
Status = RxQueryDirectory( RxContext );
// in case of session time out, STATUS_RETRY is returned
//if (Status == STATUS_RETRY) {
//in case of remote boot reconnect, the handle on the server has been delete.
//query directory has to start from beginning.
//Status = STATUS_INVALID_NETWORK_RESPONSE;
//}
break;
case IRP_MN_NOTIFY_CHANGE_DIRECTORY:
Status = RxNotifyChangeDirectory( RxContext );
if (Status == STATUS_PENDING) {
RxDereferenceAndDeleteRxContext(RxContext);
}
break;
default:
RxDbgTrace(0, Dbg, ("Invalid Directory Control Minor Function %08lx\n", capPARAMS->MinorFunction));
Status = STATUS_INVALID_DEVICE_REQUEST;
break;
}
RxDbgTrace(-1, Dbg, ("RxCommonDirectoryControl -> %08lx\n", Status));
return Status;
}
//
// Local Support Routine
//
NTSTATUS
RxQueryDirectory ( RXCOMMON_SIGNATURE )
/*++
Routine Description:
This routine performs the query directory operation. It is responsible
for either completing of enqueuing the input Irp.
Arguments:
Irp - Supplies the Irp to process
Return Value:
RXSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
RxCaptureRequestPacket;
RxCaptureFcb;
RxCaptureFobx;
RxCaptureParamBlock;
TYPE_OF_OPEN TypeOfOpen = NodeType(capFcb);
PFCB Dcb = capFcb;
CLONG UserBufferLength;
PUNICODE_STRING UniArgFileName;
FILE_INFORMATION_CLASS FileInformationClass;
BOOLEAN PostQuery = FALSE;
PAGED_CODE();
//
// Display the input values.
//
RxDbgTrace(+1, Dbg, ("RxQueryDirectory...\n", 0));
RxDbgTrace( 0, Dbg, (" Wait = %08lx\n", FlagOn(RxContext->Flags, RX_CONTEXT_FLAG_WAIT)));
RxDbgTrace( 0, Dbg, (" Irp = %08lx\n", capReqPacket));
RxDbgTrace( 0, Dbg, (" ->UserBufLength = %08lx\n", capPARAMS->Parameters.QueryDirectory.Length));
RxDbgTrace( 0, Dbg, (" ->FileName = %08lx\n", capPARAMS->Parameters.QueryDirectory.FileName));
IF_DEBUG {
if (capPARAMS->Parameters.QueryDirectory.FileName) {
RxDbgTrace( 0, Dbg, (" -> %wZ\n", capPARAMS->Parameters.QueryDirectory.FileName ));
}}
RxDbgTrace( 0, Dbg, (" ->FileInformationClass = %08lx\n", capPARAMS->Parameters.QueryDirectory.FileInformationClass));
RxDbgTrace( 0, Dbg, (" ->FileIndex = %08lx\n", capPARAMS->Parameters.QueryDirectory.FileIndex));
RxDbgTrace( 0, Dbg, (" ->UserBuffer = %08lx\n", capReqPacket->UserBuffer));
RxDbgTrace( 0, Dbg, (" ->RestartScan = %08lx\n", FlagOn( capPARAMS->Flags, SL_RESTART_SCAN )));
RxDbgTrace( 0, Dbg, (" ->ReturnSingleEntry = %08lx\n", FlagOn( capPARAMS->Flags, SL_RETURN_SINGLE_ENTRY )));
RxDbgTrace( 0, Dbg, (" ->IndexSpecified = %08lx\n", FlagOn( capPARAMS->Flags, SL_INDEX_SPECIFIED )));
RxLog(("Qry %lx %d %ld %lx %d\n",
RxContext, BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_WAIT), //1,2
capPARAMS->Parameters.QueryDirectory.Length, capPARAMS->Parameters.QueryDirectory.FileName, //3,4
capPARAMS->Parameters.QueryDirectory.FileInformationClass //5
));
RxWmiLog(LOG,
RxQueryDirectory_1,
LOGPTR(RxContext)
LOGULONG(RxContext->Flags)
LOGULONG(capPARAMS->Parameters.QueryDirectory.Length)
LOGPTR(capPARAMS->Parameters.QueryDirectory.FileName)
LOGULONG(capPARAMS->Parameters.QueryDirectory.FileInformationClass));
RxLog((" alsoqry %d %lx %lx\n",
capPARAMS->Parameters.QueryDirectory.FileIndex, capReqPacket->UserBuffer, capPARAMS->Flags //1,2,3
));
RxWmiLog(LOG,
RxQueryDirectory_2,
LOGULONG(capPARAMS->Parameters.QueryDirectory.FileIndex)
LOGPTR(capReqPacket->UserBuffer)
LOGUCHAR(capPARAMS->Flags));
if (capPARAMS->Parameters.QueryDirectory.FileName) {
RxLog((" QryName %wZ\n",
((PUNICODE_STRING)capPARAMS->Parameters.QueryDirectory.FileName)));
RxWmiLog(LOG,
RxQueryDirectory_3,
LOGUSTR(*capPARAMS->Parameters.QueryDirectory.FileName));
}
//#ifndef _CAIRO_
// if (TypeOfOpen != RDBSS_NTC_STORAGE_TYPE_DIRECTORY ) {
// RxDbgTrace(-1, Dbg, ("RxQueryDirectory -> RxStatus(INVALID_PARAMETER\n)", 0));
// return STATUS_INVALID_PARAMETER;
// }
//#endif // _CAIRO_
//
// If this is the initial query, then grab exclusive access in
// order to update the search string in the Fobx. We may
// discover that we are not the initial query once we grab the Fcb
// and downgrade our status.
//
if (capFobx == NULL) {
return STATUS_OBJECT_NAME_INVALID;
}
if (capFcb->pNetRoot->Type != NET_ROOT_DISK) {
return STATUS_INVALID_DEVICE_REQUEST;
}
//
// Reference our input parameters to make things easier
//
UserBufferLength = capPARAMS->Parameters.QueryDirectory.Length;
FileInformationClass = capPARAMS->Parameters.QueryDirectory.FileInformationClass;
UniArgFileName = (PUNICODE_STRING) capPARAMS->Parameters.QueryDirectory.FileName;
RxContext->QueryDirectory.FileIndex = capPARAMS->Parameters.QueryDirectory.FileIndex;
RxContext->QueryDirectory.RestartScan = BooleanFlagOn(capPARAMS->Flags, SL_RESTART_SCAN);
RxContext->QueryDirectory.ReturnSingleEntry = BooleanFlagOn(capPARAMS->Flags, SL_RETURN_SINGLE_ENTRY);
RxContext->QueryDirectory.IndexSpecified = BooleanFlagOn(capPARAMS->Flags, SL_INDEX_SPECIFIED);
RxContext->QueryDirectory.InitialQuery = (BOOLEAN)((capFobx->UnicodeQueryTemplate.Buffer == NULL) &&
!FlagOn(capFobx->Flags, FOBX_FLAG_MATCH_ALL));
if (RxContext->QueryDirectory.IndexSpecified) {
return STATUS_NOT_IMPLEMENTED;
}
if (RxContext->QueryDirectory.InitialQuery) {
Status = RxAcquireExclusiveFcb(RxContext,Dcb);
if (Status == STATUS_LOCK_NOT_GRANTED) {
PostQuery = TRUE;
} else if (Status != STATUS_SUCCESS) {
RxDbgTrace(0, Dbg, ("RxQueryDirectory -> Could not acquire Dcb(%lx) %lx\n",Dcb,Status));
return Status;
} else if (capFobx->UnicodeQueryTemplate.Buffer != NULL) {
RxContext->QueryDirectory.InitialQuery = FALSE;
RxConvertToSharedFcb( RxContext, Dcb );
}
} else {
Status = RxAcquireExclusiveFcb(RxContext,Dcb);
if (Status == STATUS_LOCK_NOT_GRANTED) {
PostQuery = TRUE;
} else if (Status != STATUS_SUCCESS) {
RxDbgTrace(0, Dbg, ("RxQueryDirectory -> Could not acquire Dcb(%lx) %lx\n",Dcb,Status));
return Status;
}
}
if (PostQuery) {
RxDbgTrace(0, Dbg, ("RxQueryDirectory -> Enqueue to Fsp\n", 0));
Status = RxFsdPostRequest( RxContext );
RxDbgTrace(-1, Dbg, ("RxQueryDirectory -> %08lx\n", Status));
return Status;
}
if (FlagOn(Dcb->FcbState,FCB_STATE_ORPHANED)) {
RxReleaseFcb( RxContext, Dcb );
return STATUS_FILE_CLOSED;
}
try {
Status = STATUS_SUCCESS;
//
// Determine where to start the scan. Highest priority is given
// to the file index. Lower priority is the restart flag. If
// neither of these is specified, then the existing value in the
// Fobx is used.
//
if (!RxContext->QueryDirectory.IndexSpecified && RxContext->QueryDirectory.RestartScan) {
RxContext->QueryDirectory.FileIndex = 0;
}
//
// If this is the first try then allocate a buffer for the file
// name.
//
if (RxContext->QueryDirectory.InitialQuery) {
ASSERT( !FlagOn( capFobx->Flags, FOBX_FLAG_FREE_UNICODE ) );
//
// If either:
//
// - No name was specified
// - An empty name was specified
// - We received a '*'
// - The user specified the DOS equivolent of ????????.???
//
// then match all names.
//
if ((UniArgFileName == NULL) ||
(UniArgFileName->Length == 0) ||
(UniArgFileName->Buffer == NULL) ||
((UniArgFileName->Length == sizeof(WCHAR)) &&
(UniArgFileName->Buffer[0] == L'*')) ||
((UniArgFileName->Length == 12*sizeof(WCHAR)) &&
(RtlCompareMemory( UniArgFileName->Buffer,
Rx8QMdot3QM,
12*sizeof(WCHAR) )) == 12*sizeof(WCHAR))) {
capFobx->ContainsWildCards = TRUE;
capFobx->UnicodeQueryTemplate.Buffer = RxStarForTemplate;
capFobx->UnicodeQueryTemplate.Length = sizeof(WCHAR);
capFobx->UnicodeQueryTemplate.MaximumLength = sizeof(WCHAR);
SetFlag( capFobx->Flags, FOBX_FLAG_MATCH_ALL );
} else {
PVOID TemplateBuffer;
//
// See if the name has wild cards & allocate template buffer
//
capFobx->ContainsWildCards =
FsRtlDoesNameContainWildCards( UniArgFileName );
TemplateBuffer = RxAllocatePoolWithTag(
PagedPool,
UniArgFileName->Length,
RX_DIRCTL_POOLTAG);
if (TemplateBuffer != NULL) {
//
// Validate that the length is in sizeof(WCHAR) increments
//
if(FlagOn( UniArgFileName->Length, 1 )) {
Status = STATUS_INVALID_PARAMETER;
RxFreePool( TemplateBuffer );
} else {
RxDbgTrace( 0, Dbg, ("RxQueryDirectory -> TplateBuffer = %08lx\n", TemplateBuffer) );
capFobx->UnicodeQueryTemplate.Buffer = TemplateBuffer;
capFobx->UnicodeQueryTemplate.Length = UniArgFileName->Length;
capFobx->UnicodeQueryTemplate.MaximumLength = UniArgFileName->Length;
RtlMoveMemory( capFobx->UnicodeQueryTemplate.Buffer,
UniArgFileName->Buffer,UniArgFileName->Length );
RxDbgTrace( 0, Dbg, ("RxQueryDirectory -> Template = %wZ\n", &Fobx->UnicodeQueryTemplate) );
SetFlag( capFobx->Flags, FOBX_FLAG_FREE_UNICODE );
}
} else {
Status = STATUS_INSUFFICIENT_RESOURCES;
}
}
if (Status == STATUS_SUCCESS) {
//
// We convert to shared access before going to the net.
//
RxConvertToSharedFcb( RxContext, Dcb );
}
}
if (Status == STATUS_SUCCESS) {
RxLockUserBuffer( RxContext, IoModifyAccess, UserBufferLength );
RxContext->Info.FileInformationClass = FileInformationClass;
RxContext->Info.Buffer = RxNewMapUserBuffer( RxContext );
RxContext->Info.LengthRemaining = UserBufferLength;
if (RxContext->Info.Buffer != NULL) {
MINIRDR_CALL(Status,RxContext,Dcb->MRxDispatch,MRxQueryDirectory,
(RxContext)
); //minirdr updates the fileindex
if (RxContext->PostRequest) {
RxDbgTrace(0, Dbg, ("RxQueryDirectory -> Enqueue to Fsp from minirdr\n", 0));
Status = RxFsdPostRequest( RxContext );
} else {
capReqPacket->IoStatus.Information = UserBufferLength - RxContext->Info.LengthRemaining;
}
} else {
if (capReqPacket->MdlAddress != NULL) {
Status = STATUS_INSUFFICIENT_RESOURCES;
} else {
Status = STATUS_INVALID_PARAMETER;
}
}
}
} finally {
DebugUnwind( RxQueryDirectory );
RxReleaseFcb( RxContext, Dcb );
RxDbgTrace(-1, Dbg, ("RxQueryDirectory -> %08lx\n", Status));
}
return Status;
}
NTSTATUS
RxNotifyChangeDirectory ( RXCOMMON_SIGNATURE )
/*++
Routine Description:
This routine performs the notify change directory operation. It is
responsible for either completing or enqueuing the operation.
Arguments:
RxContext - the RDBSS context for the operation
Return Value:
RXSTATUS - The return status for the operation
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
RxCaptureRequestPacket;
RxCaptureFcb;
RxCaptureFobx;
RxCaptureParamBlock;
ULONG CompletionFilter;
BOOLEAN WatchTree;
PLOWIO_CONTEXT pLowIoContext = &RxContext->LowIoContext;
TYPE_OF_OPEN TypeOfOpen = NodeType(capFcb);
PAGED_CODE();
RxDbgTrace(+1, Dbg, ("RxNotifyChangeDirectory...\n", 0));
RxDbgTrace( 0, Dbg, (" Wait = %08lx\n", FlagOn(RxContext->Flags, RX_CONTEXT_FLAG_WAIT)));
RxDbgTrace( 0, Dbg, (" Irp = %08lx\n", capReqPacket));
RxDbgTrace( 0, Dbg, (" ->CompletionFilter = %08lx\n", capPARAMS->Parameters.NotifyDirectory.CompletionFilter));
// Always set the wait flag in the Irp context for the original request.
SetFlag( RxContext->Flags, RX_CONTEXT_FLAG_WAIT );
// Check on the type of open. We return invalid parameter for all
// but UserDirectoryOpens.
RxInitializeLowIoContext(pLowIoContext,LOWIO_OP_NOTIFY_CHANGE_DIRECTORY);
// Reference our input parameter to make things easier
CompletionFilter = capPARAMS->Parameters.NotifyDirectory.CompletionFilter;
WatchTree = BooleanFlagOn( capPARAMS->Flags, SL_WATCH_TREE );
try {
RxLockUserBuffer(
RxContext,
IoWriteAccess,
capPARAMS->Parameters.NotifyDirectory.Length);
pLowIoContext->ParamsFor.NotifyChangeDirectory.WatchTree = WatchTree;
pLowIoContext->ParamsFor.NotifyChangeDirectory.CompletionFilter = CompletionFilter;
pLowIoContext->ParamsFor.NotifyChangeDirectory.NotificationBufferLength =
capPARAMS->Parameters.NotifyDirectory.Length;
if (capReqPacket->MdlAddress != NULL) {
pLowIoContext->ParamsFor.NotifyChangeDirectory.pNotificationBuffer =
MmGetSystemAddressForMdlSafe(
capReqPacket->MdlAddress,
NormalPagePriority);
if (pLowIoContext->ParamsFor.NotifyChangeDirectory.pNotificationBuffer
== NULL) {
Status = STATUS_INSUFFICIENT_RESOURCES;
} else {
Status = RxLowIoSubmit(
RxContext,
RxLowIoNotifyChangeDirectoryCompletion);
}
} else {
Status = STATUS_INVALID_PARAMETER;
}
} finally {
DebugUnwind( RxNotifyChangeDirectory );
RxDbgTrace(-1, Dbg, ("RxNotifyChangeDirectory -> %08lx\n", Status));
}
return Status;
}
NTSTATUS
RxLowIoNotifyChangeDirectoryCompletion( RXCOMMON_SIGNATURE )
/*++
Routine Description:
This is the completion routine for NotifyChangeDirectory requests passed down
to thr mini redirectors
Arguments:
RxContext -- the RDBSS context associated with the operation
Return Value:
RXSTATUS - The return status for the operation
--*/
{
RxCaptureRequestPacket;
NTSTATUS Status;
PLOWIO_CONTEXT pLowIoContext = &RxContext->LowIoContext;
PAGED_CODE();
Status = RxContext->StoredStatus;
RxDbgTrace(+1, Dbg, ("RxLowIoChangeNotifyDirectoryShellCompletion entry Status = %08lx\n", Status));
capReqPacket->IoStatus.Information = RxContext->InformationToReturn;
capReqPacket->IoStatus.Status = Status;
RxDbgTrace(-1, Dbg, ("RxLowIoChangeNotifyDirectoryShellCompletion exit Status = %08lx\n", Status));
return Status;
}
Reference in a new issue Copy permalink