5199 lines
142 KiB
C
5199 lines
142 KiB
C
/*++
|
||
|
||
Copyright (c) 1989 Microsoft Corporation
|
||
|
||
|
||
Module Name:
|
||
|
||
open.c
|
||
|
||
Abstract:
|
||
|
||
This module contains the routine called by processing routines for
|
||
the various flavors of Open SMBs (SrvCreateFile) and its
|
||
subroutines.
|
||
|
||
!!! Need to use SrvEnableFcbOpens to determine whether to fold FCB
|
||
opens together.
|
||
|
||
Author:
|
||
|
||
David Treadwell (davidtr) 23-Nov-1989
|
||
Chuck Lenzmeier (chuckl)
|
||
Manny Weiser (mannyw)
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "precomp.h"
|
||
#include "open.tmh"
|
||
#pragma hdrstop
|
||
|
||
#define BugCheckFileId SRV_FILE_OPEN
|
||
|
||
//
|
||
// Local functions
|
||
//
|
||
|
||
NTSTATUS
|
||
DoNormalOpen(
|
||
OUT PRFCB *Rfcb,
|
||
IN PMFCB Mfcb,
|
||
IN OUT PWORK_CONTEXT WorkContext,
|
||
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
||
IN USHORT SmbDesiredAccess,
|
||
IN USHORT SmbFileAttributes,
|
||
IN USHORT SmbOpenFunction,
|
||
IN ULONG SmbAllocationSize,
|
||
IN PUNICODE_STRING RelativeName,
|
||
IN PVOID EaBuffer OPTIONAL,
|
||
IN ULONG EaLength,
|
||
OUT PULONG EaErrorOffset OPTIONAL,
|
||
OUT PBOOLEAN LfcbAddedToMfcbList,
|
||
IN OPLOCK_TYPE RequestedOplockType
|
||
);
|
||
|
||
NTSTATUS
|
||
DoCompatibilityOpen(
|
||
OUT PRFCB *Rfcb,
|
||
IN PMFCB Mfcb,
|
||
IN OUT PWORK_CONTEXT WorkContext,
|
||
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
||
IN USHORT SmbDesiredAccess,
|
||
IN USHORT SmbFileAttributes,
|
||
IN USHORT SmbOpenFunction,
|
||
IN ULONG SmbAllocationSize,
|
||
IN PUNICODE_STRING RelativeName,
|
||
IN PVOID EaBuffer OPTIONAL,
|
||
IN ULONG EaLength,
|
||
OUT PULONG EaErrorOffset OPTIONAL,
|
||
OUT PBOOLEAN LfcbAddedToMfcbList,
|
||
IN OPLOCK_TYPE RequestedOplockType
|
||
);
|
||
|
||
|
||
NTSTATUS
|
||
DoFcbOpen(
|
||
OUT PRFCB *Rfcb,
|
||
IN PMFCB Mfcb,
|
||
IN OUT PWORK_CONTEXT WorkContext,
|
||
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
||
IN USHORT SmbFileAttributes,
|
||
IN USHORT SmbOpenFunction,
|
||
IN ULONG SmbAllocationSize,
|
||
IN PUNICODE_STRING RelativeName,
|
||
IN PVOID EaBuffer OPTIONAL,
|
||
IN ULONG EaLength,
|
||
OUT PULONG EaErrorOffset OPTIONAL,
|
||
OUT PBOOLEAN LfcbAddedToMfcbList
|
||
);
|
||
|
||
NTSTATUS
|
||
DoCommDeviceOpen (
|
||
IN OUT PWORK_CONTEXT WorkContext,
|
||
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
||
IN USHORT SmbDesiredAccess,
|
||
IN USHORT SmbOpenFunction,
|
||
OUT PRFCB *Rfcb,
|
||
IN PMFCB Mfcb,
|
||
OUT PBOOLEAN LfcbAddedToMfcbList
|
||
);
|
||
|
||
PTABLE_ENTRY
|
||
FindAndClaimFileTableEntry (
|
||
IN PCONNECTION Connection,
|
||
OUT PSHORT FidIndex
|
||
);
|
||
|
||
NTSTATUS
|
||
CompleteOpen(
|
||
OUT PRFCB *Rfcb,
|
||
IN PMFCB Mfcb,
|
||
IN OUT PWORK_CONTEXT WorkContext,
|
||
IN PLFCB ExistingLfcb OPTIONAL,
|
||
IN HANDLE FileHandle OPTIONAL,
|
||
IN PACCESS_MASK RemoteGrantedAccess OPTIONAL,
|
||
IN ULONG ShareAccess,
|
||
IN ULONG FileMode,
|
||
IN BOOLEAN CompatibilityOpen,
|
||
IN BOOLEAN FcbOpen,
|
||
OUT PBOOLEAN LfcbAddedToMfcbList
|
||
);
|
||
|
||
BOOLEAN SRVFASTCALL
|
||
MapCompatibilityOpen(
|
||
IN PUNICODE_STRING FileName,
|
||
IN OUT PUSHORT SmbDesiredAccess
|
||
);
|
||
|
||
NTSTATUS SRVFASTCALL
|
||
MapDesiredAccess(
|
||
IN USHORT SmbDesiredAccess,
|
||
OUT PACCESS_MASK NtDesiredAccess
|
||
);
|
||
|
||
NTSTATUS SRVFASTCALL
|
||
MapOpenFunction(
|
||
IN USHORT SmbOpenFunction,
|
||
OUT PULONG CreateDisposition
|
||
);
|
||
|
||
NTSTATUS SRVFASTCALL
|
||
MapShareAccess(
|
||
IN USHORT SmbDesiredAccess,
|
||
OUT PULONG NtShareAccess
|
||
);
|
||
|
||
NTSTATUS SRVFASTCALL
|
||
MapCacheHints(
|
||
IN USHORT SmbDesiredAccess,
|
||
IN OUT PULONG NtCreateFlags
|
||
);
|
||
|
||
BOOLEAN
|
||
SetDefaultPipeMode (
|
||
IN HANDLE FileHandle
|
||
);
|
||
|
||
NTSTATUS
|
||
RemapPipeName(
|
||
IN PANSI_STRING AnsiServerName OPTIONAL,
|
||
IN PUNICODE_STRING ServerName OPTIONAL,
|
||
IN OUT PUNICODE_STRING NewRelativeName,
|
||
OUT PBOOLEAN Remapped
|
||
);
|
||
|
||
BOOLEAN
|
||
SrvFailMdlReadDev (
|
||
IN PFILE_OBJECT FileObject,
|
||
IN PLARGE_INTEGER FileOffset,
|
||
IN ULONG Length,
|
||
IN ULONG LockKey,
|
||
OUT PMDL *MdlChain,
|
||
OUT PIO_STATUS_BLOCK IoStatus,
|
||
IN PDEVICE_OBJECT DeviceObject
|
||
);
|
||
|
||
BOOLEAN
|
||
SrvFailPrepareMdlWriteDev(
|
||
IN PFILE_OBJECT FileObject,
|
||
IN PLARGE_INTEGER FileOffset,
|
||
IN ULONG Length,
|
||
IN ULONG LockKey,
|
||
OUT PMDL *MdlChain,
|
||
OUT PIO_STATUS_BLOCK IoStatus,
|
||
IN PDEVICE_OBJECT DeviceObject
|
||
);
|
||
|
||
#ifdef ALLOC_PRAGMA
|
||
#pragma alloc_text( PAGE, RemapPipeName )
|
||
#pragma alloc_text( PAGE, SrvCreateFile )
|
||
#pragma alloc_text( PAGE, DoNormalOpen )
|
||
#pragma alloc_text( PAGE, DoCompatibilityOpen )
|
||
#pragma alloc_text( PAGE, DoFcbOpen )
|
||
#pragma alloc_text( PAGE, CompleteOpen )
|
||
#pragma alloc_text( PAGE, MapCompatibilityOpen )
|
||
#pragma alloc_text( PAGE, MapDesiredAccess )
|
||
#pragma alloc_text( PAGE, MapOpenFunction )
|
||
#pragma alloc_text( PAGE, MapCacheHints )
|
||
#pragma alloc_text( PAGE, MapShareAccess )
|
||
#pragma alloc_text( PAGE, SrvNtCreateFile )
|
||
#pragma alloc_text( PAGE, SetDefaultPipeMode )
|
||
#pragma alloc_text( PAGE8FIL, FindAndClaimFileTableEntry )
|
||
#pragma alloc_text( PAGE, SrvFailMdlReadDev )
|
||
#pragma alloc_text( PAGE, SrvFailPrepareMdlWriteDev )
|
||
#endif
|
||
|
||
|
||
NTSTATUS
|
||
RemapPipeName(
|
||
IN PANSI_STRING AnsiServerName,
|
||
IN PUNICODE_STRING UnicodeName,
|
||
IN OUT PUNICODE_STRING NewRelativeName,
|
||
OUT PBOOLEAN Remapped
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Remaps a pipe name by prepending "$$\<AnsiServerName>\" to the
|
||
relative pipe name (without the trailing spaces in AnsiServerName).
|
||
|
||
Arguments:
|
||
|
||
AnsiServerName - NetBIOS server name, or
|
||
UnicodeName - UNICODE server name
|
||
|
||
NewRelativeName - pointer to pipe name; on successful return,
|
||
points to newly allocated memory for remapped pipe name.
|
||
This memory must be freed by the caller.
|
||
|
||
Remapped - set to TRUE if the name was remapped
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Indicates what occurred.
|
||
|
||
--*/
|
||
|
||
{
|
||
UNICODE_STRING OldRelativeName;
|
||
UNICODE_STRING UnicodeServerName;
|
||
ULONG nameLength;
|
||
PWCH nextLocation;
|
||
NTSTATUS status;
|
||
int i;
|
||
|
||
PAGED_CODE();
|
||
|
||
*Remapped = FALSE;
|
||
|
||
//
|
||
// Do not remap the pipe name if it is in our SrvNoRemapPipeNames list
|
||
//
|
||
ACQUIRE_LOCK_SHARED( &SrvConfigurationLock );
|
||
|
||
for ( i = 0; SrvNoRemapPipeNames[i] != NULL ; i++ ) {
|
||
|
||
UNICODE_STRING NoRemap;
|
||
|
||
RtlInitUnicodeString( &NoRemap, SrvNoRemapPipeNames[i] );
|
||
|
||
if( RtlCompareUnicodeString( &NoRemap, NewRelativeName, TRUE ) == 0 ) {
|
||
|
||
//
|
||
// This is a pipe name that we are not supposed to remap. We
|
||
// return STATUS_SUCCESS, but indicate to our caller that we did
|
||
// not remap the pipe name
|
||
//
|
||
RELEASE_LOCK( &SrvConfigurationLock );
|
||
return STATUS_SUCCESS;
|
||
}
|
||
}
|
||
|
||
RELEASE_LOCK( &SrvConfigurationLock );
|
||
|
||
//
|
||
// Save RelativeName before changing it to point to new memory.
|
||
//
|
||
|
||
OldRelativeName = *NewRelativeName;
|
||
|
||
//
|
||
// Trim the trailing spaces from the server name.
|
||
// We know that the last character is a space,
|
||
// because server name is a netbios name.
|
||
//
|
||
|
||
if( !ARGUMENT_PRESENT( UnicodeName ) ) {
|
||
|
||
USHORT SavedLength;
|
||
|
||
ASSERT(AnsiServerName->Length == 16);
|
||
ASSERT(AnsiServerName->Buffer[AnsiServerName->Length - 1] == ' ');
|
||
|
||
SavedLength = AnsiServerName->Length;
|
||
|
||
while (AnsiServerName->Length > 0 &&
|
||
AnsiServerName->Buffer[AnsiServerName->Length - 1] == ' ') {
|
||
|
||
AnsiServerName->Length--;
|
||
}
|
||
|
||
//
|
||
// Convert the server name from ANSI to Unicode.
|
||
//
|
||
status = RtlAnsiStringToUnicodeString(
|
||
&UnicodeServerName,
|
||
AnsiServerName,
|
||
TRUE);
|
||
|
||
AnsiServerName->Length = SavedLength;
|
||
|
||
if (! NT_SUCCESS(status)) {
|
||
return status;
|
||
}
|
||
|
||
} else {
|
||
|
||
UnicodeServerName = *UnicodeName;
|
||
|
||
}
|
||
|
||
//
|
||
// Allocate space for new relative name ("$$\server\oldrelative").
|
||
// Start by calculating the string length, and then add one more WCHAR
|
||
// for zero-termination.
|
||
//
|
||
|
||
nameLength = (sizeof(L'$') +
|
||
sizeof(L'$') +
|
||
sizeof(L'\\') +
|
||
UnicodeServerName.Length +
|
||
sizeof(L'\\') +
|
||
OldRelativeName.Length);
|
||
|
||
NewRelativeName->Length = (USHORT)nameLength;
|
||
|
||
if( NewRelativeName->Length != nameLength ) {
|
||
|
||
//
|
||
// Oh no -- string length overflow!
|
||
//
|
||
|
||
if( !ARGUMENT_PRESENT( UnicodeName ) ) {
|
||
RtlFreeUnicodeString(&UnicodeServerName);
|
||
}
|
||
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
NewRelativeName->MaximumLength =
|
||
NewRelativeName->Length + sizeof(L'\0');
|
||
|
||
NewRelativeName->Buffer =
|
||
ALLOCATE_HEAP_COLD(NewRelativeName->MaximumLength, BlockTypeDataBuffer);
|
||
|
||
if (NewRelativeName->Buffer == NULL) {
|
||
|
||
if( !ARGUMENT_PRESENT( UnicodeName ) ) {
|
||
RtlFreeUnicodeString(&UnicodeServerName);
|
||
}
|
||
|
||
return STATUS_INSUFF_SERVER_RESOURCES;
|
||
}
|
||
|
||
RtlZeroMemory(NewRelativeName->Buffer, NewRelativeName->MaximumLength);
|
||
|
||
nextLocation = NewRelativeName->Buffer;
|
||
|
||
//
|
||
// Copy strings and characters to new relative name.
|
||
//
|
||
*nextLocation++ = L'$';
|
||
*nextLocation++ = L'$';
|
||
*nextLocation++ = L'\\';
|
||
|
||
RtlCopyMemory(
|
||
nextLocation,
|
||
UnicodeServerName.Buffer,
|
||
UnicodeServerName.Length
|
||
);
|
||
|
||
nextLocation += (UnicodeServerName.Length / sizeof(WCHAR));
|
||
|
||
*nextLocation++ = L'\\';
|
||
|
||
RtlCopyMemory(
|
||
nextLocation,
|
||
OldRelativeName.Buffer,
|
||
OldRelativeName.Length
|
||
);
|
||
|
||
if( !ARGUMENT_PRESENT( UnicodeName ) ) {
|
||
//
|
||
// Free UnicodeServerName.
|
||
//
|
||
RtlFreeUnicodeString(&UnicodeServerName);
|
||
}
|
||
|
||
*Remapped = TRUE;
|
||
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
NTSTATUS
|
||
SrvCreateFile(
|
||
IN OUT PWORK_CONTEXT WorkContext,
|
||
IN USHORT SmbDesiredAccess,
|
||
IN USHORT SmbFileAttributes,
|
||
IN USHORT SmbOpenFunction,
|
||
IN ULONG SmbAllocationSize,
|
||
IN PCHAR SmbFileName,
|
||
IN PCHAR EndOfSmbFileName,
|
||
IN PVOID EaBuffer OPTIONAL,
|
||
IN ULONG EaLength,
|
||
OUT PULONG EaErrorOffset OPTIONAL,
|
||
IN OPLOCK_TYPE RequestedOplockType,
|
||
IN PRESTART_ROUTINE RestartRoutine
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Does most of the operations necessary to open or create a file.
|
||
First the UID and TID are verified and the corresponding session and
|
||
tree connect blocks located. The input file name name is
|
||
canonicalized, and a fully qualified name is formed. An appropriate
|
||
subroutine is called to do the open, based on whether this is a
|
||
normal, compatibility mode, or FCB open.
|
||
|
||
Arguments:
|
||
|
||
WorkContext - Work context block for the operation.
|
||
|
||
SmbDesiredAccess - The desired access in SMB protocol format.
|
||
|
||
SmbFileAttributes - File attributes in SMB protocol format.
|
||
|
||
SmbOpenFunction - Open function in SMB protocol format.
|
||
|
||
SmbAllocationSize - Allocation size for new files.
|
||
|
||
SmbFileName - A pointer to the zero-terminated file name in the
|
||
request SMB. NOTE: This pointer should NOT point to the ASCII
|
||
format indicator (\004) present in some SMBs!
|
||
|
||
EndOfSmbFileName - a pointer to the last possible character that
|
||
the file name can be in. If the name extands beyond this location
|
||
without a zero terminator, SrvCanonicalizePathName will fail.
|
||
|
||
EaBuffer - Optional pointer to a full EA list to pass to SrvIoCreateFile.
|
||
|
||
EaLength - Length of the EA buffer.
|
||
|
||
EaErrorOffset - Optional pointer to the location in which to write
|
||
the offset to the EA that caused an error.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Indicates what occurred.
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS status;
|
||
|
||
PMFCB mfcb;
|
||
PNONPAGED_MFCB nonpagedMfcb;
|
||
PRFCB rfcb;
|
||
|
||
PSESSION session;
|
||
PTREE_CONNECT treeConnect;
|
||
|
||
UNICODE_STRING relativeName;
|
||
UNICODE_STRING pipeRelativeName;
|
||
BOOLEAN pipeRelativeNameAllocated = FALSE;
|
||
UNICODE_STRING fullName;
|
||
SHARE_TYPE shareType;
|
||
|
||
ULONG error;
|
||
ULONG jobId;
|
||
|
||
ULONG hashValue;
|
||
|
||
ULONG attributes;
|
||
ULONG openRetries;
|
||
BOOLEAN isUnicode;
|
||
BOOLEAN caseInsensitive;
|
||
|
||
PSRV_LOCK mfcbLock;
|
||
|
||
//
|
||
// NOTE ON MFCB REFERENCE COUNT HANDLING
|
||
//
|
||
// After finding or creating an MFCB for a file, we increment the
|
||
// MFCB reference count an extra time to simplify our
|
||
// synchronization logic. We hold the MfcbListLock lock while
|
||
// finding/creating the MFCB, but release it after acquiring the the
|
||
// per-MFCB lock. We then call one of the DoXxxOpen routines, which
|
||
// may need to queue an LFCB to the MFCB and thus need to increment
|
||
// the count. But they can't, because the MFCB list lock may not be
|
||
// acquired while the per-MFCB lock is held because of deadlock
|
||
// potential. The boolean LfcbAddedToMfcbList returned from the
|
||
// routines indicates whether they actually queued an LFCB to the
|
||
// MFCB. If they didn't, we need to release the extra reference.
|
||
//
|
||
// Note that it isn't often that we actually have to dereference the
|
||
// MFCB. This only occurs when 1) the open fails, or 2) a
|
||
// compatibility mode or FCB open succeeds when the client already
|
||
// has the file open.
|
||
//
|
||
|
||
BOOLEAN lfcbAddedToMfcbList;
|
||
|
||
PAGED_CODE( );
|
||
|
||
//
|
||
// Assume we won't need a temporary open.
|
||
//
|
||
|
||
WorkContext->Parameters2.Open.TemporaryOpen = FALSE;
|
||
|
||
//
|
||
// If a session block has not already been assigned to the current
|
||
// work context, verify the UID. If verified, the address of the
|
||
// session block corresponding to this user is stored in the
|
||
// WorkContext block and the session block is referenced.
|
||
//
|
||
// Find the tree connect corresponding to the given TID if a tree
|
||
// connect pointer has not already been put in the WorkContext block
|
||
// by an AndX command or a previous call to SrvCreateFile.
|
||
//
|
||
|
||
status = SrvVerifyUidAndTid(
|
||
WorkContext,
|
||
&session,
|
||
&treeConnect,
|
||
ShareTypeWild
|
||
);
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
IF_DEBUG(SMB_ERRORS) {
|
||
KdPrint(( "SrvCreateFile: Invalid UID or TID\n" ));
|
||
}
|
||
return status;
|
||
}
|
||
|
||
//
|
||
// If the session has expired, return that info
|
||
//
|
||
if( session->IsSessionExpired )
|
||
{
|
||
return SESSION_EXPIRED_STATUS_CODE;
|
||
}
|
||
|
||
//
|
||
// Decide if we're case sensitive or not
|
||
//
|
||
caseInsensitive = (WorkContext->RequestHeader->Flags & SMB_FLAGS_CASE_INSENSITIVE) ||
|
||
session->UsingUppercasePaths;
|
||
|
||
//
|
||
// Here we begin share type specific processing.
|
||
//
|
||
|
||
shareType = treeConnect->Share->ShareType;
|
||
|
||
//
|
||
// If this operation may block, and we are running short of
|
||
// free work items, fail this SMB with an out of resources error.
|
||
// Note that a disk open will block if the file is currently oplocked.
|
||
//
|
||
|
||
if ( shareType == ShareTypeDisk && !WorkContext->BlockingOperation ) {
|
||
|
||
if ( SrvReceiveBufferShortage( ) ) {
|
||
|
||
SrvStatistics.BlockingSmbsRejected++;
|
||
SrvSetSmbError( WorkContext, STATUS_INSUFF_SERVER_RESOURCES );
|
||
return STATUS_INSUFF_SERVER_RESOURCES;
|
||
|
||
} else {
|
||
|
||
//
|
||
// SrvBlockingOpsInProgress has already been incremented.
|
||
// Flag this work item as a blocking operation.
|
||
//
|
||
|
||
WorkContext->BlockingOperation = TRUE;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
isUnicode = SMB_IS_UNICODE( WorkContext );
|
||
|
||
switch ( shareType ) {
|
||
|
||
case ShareTypePrint:
|
||
|
||
//
|
||
// Allocate space to hold the file name we're going to open.
|
||
//
|
||
|
||
fullName.MaximumLength = MAXIMUM_FILENAME_LENGTH * sizeof(WCHAR);
|
||
fullName.Buffer = ALLOCATE_HEAP_COLD(
|
||
fullName.MaximumLength,
|
||
BlockTypeDataBuffer
|
||
);
|
||
if ( fullName.Buffer == NULL ) {
|
||
return STATUS_INSUFF_SERVER_RESOURCES;
|
||
}
|
||
|
||
//
|
||
// Get a print file name to use for spooling the request.
|
||
// We open this as a disk file, use normal writes to get the
|
||
// data, then call ScheduleJob( ) in XACTSRV to start the
|
||
// actual printing process.
|
||
//
|
||
|
||
status = SrvAddPrintJob(
|
||
WorkContext,
|
||
WorkContext->TreeConnect->Share->Type.hPrinter,
|
||
&fullName,
|
||
&jobId,
|
||
&error
|
||
);
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
IF_DEBUG(SMB_ERRORS) {
|
||
KdPrint(( "SrvCreateFile: SrvAddPrintJob failed: %lx (%ld)\n",
|
||
status, error ));
|
||
}
|
||
FREE_HEAP( fullName.Buffer );
|
||
if ( error != NO_ERROR ) {
|
||
ASSERT( SrvErrorCode(error) == error );
|
||
status = (NTSTATUS)(SRV_WIN32_STATUS | error);
|
||
}
|
||
return status;
|
||
}
|
||
|
||
//
|
||
// Scan the Master File Table to see if the named file is already
|
||
// open.
|
||
//
|
||
mfcb = SrvFindMfcb( &fullName, caseInsensitive, &mfcbLock, &hashValue, WorkContext );
|
||
|
||
if ( mfcb == NULL ) {
|
||
|
||
//
|
||
// There is no MFCB for this file. Create one.
|
||
//
|
||
|
||
mfcb = SrvCreateMfcb( &fullName, WorkContext, hashValue );
|
||
|
||
if ( mfcb == NULL ) {
|
||
|
||
//
|
||
// Failure to add open file instance to MFT.
|
||
//
|
||
|
||
if( mfcbLock ) {
|
||
RELEASE_LOCK( mfcbLock );
|
||
}
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "SrvCreateFile: Unable to allocate MFCB\n" ));
|
||
}
|
||
|
||
FREE_HEAP( fullName.Buffer );
|
||
|
||
//
|
||
// Free up the Job ID.
|
||
//
|
||
|
||
SrvSchedulePrintJob(
|
||
WorkContext->TreeConnect->Share->Type.hPrinter,
|
||
jobId
|
||
);
|
||
|
||
return STATUS_INSUFF_SERVER_RESOURCES;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
//
|
||
// Increment the MFCB reference count. See the note at the beginning of this routine.
|
||
//
|
||
|
||
mfcb->BlockHeader.ReferenceCount++;
|
||
UPDATE_REFERENCE_HISTORY( mfcb, FALSE );
|
||
|
||
//
|
||
// Grab the MFCB-based lock to serialize opens of the same file
|
||
// and release the MFCB list lock.
|
||
//
|
||
|
||
nonpagedMfcb = mfcb->NonpagedMfcb;
|
||
RELEASE_LOCK( mfcbLock );
|
||
ACQUIRE_LOCK( &nonpagedMfcb->Lock );
|
||
|
||
//
|
||
// Set up the share access and desired access in SMB terms.
|
||
// We will only write to the file, so just request write
|
||
// as the desired access. As an optimization, the spooler
|
||
// may read from the file before we finish writing to it,
|
||
// so allow other readers.
|
||
//
|
||
|
||
SmbDesiredAccess = SMB_DA_ACCESS_WRITE | SMB_DA_SHARE_DENY_WRITE | SMB_LR_SEQUENTIAL;
|
||
|
||
//
|
||
// Set up the open function to create the file it it doesn't
|
||
// exist and to truncate it if it does exist. There shouldn't
|
||
// be preexisting data in the file, hence the truncation.
|
||
//
|
||
// !!! The spooler may change to create the file for us, in which
|
||
// case this should change to only truncate.
|
||
|
||
SmbOpenFunction = SMB_OFUN_CREATE_CREATE | SMB_OFUN_OPEN_TRUNCATE;
|
||
|
||
//
|
||
// This is a normal sharing mode open. Do the actual open
|
||
// of the disk file.
|
||
//
|
||
|
||
status = DoNormalOpen(
|
||
&rfcb,
|
||
mfcb,
|
||
WorkContext,
|
||
&WorkContext->Irp->IoStatus,
|
||
SmbDesiredAccess,
|
||
SmbFileAttributes,
|
||
SmbOpenFunction,
|
||
SmbAllocationSize,
|
||
&fullName,
|
||
NULL,
|
||
0,
|
||
0,
|
||
&lfcbAddedToMfcbList,
|
||
RequestedOplockType
|
||
);
|
||
|
||
//
|
||
// If the open worked, set up the Job ID in the LFCB.
|
||
//
|
||
|
||
if ( NT_SUCCESS(status) ) {
|
||
|
||
rfcb->Lfcb->JobId = jobId;
|
||
|
||
} else {
|
||
|
||
//
|
||
// Free up the Job ID if the open failed.
|
||
//
|
||
|
||
SrvSchedulePrintJob(
|
||
WorkContext->TreeConnect->Share->Type.hPrinter,
|
||
jobId
|
||
);
|
||
}
|
||
|
||
//
|
||
// Release the Open serialization lock and dereference the MFCB.
|
||
//
|
||
|
||
RELEASE_LOCK( &nonpagedMfcb->Lock );
|
||
|
||
//
|
||
// If DoNormalOpen didn't queue an LFCB to the MFCB, release the
|
||
// extra reference that we added.
|
||
//
|
||
|
||
if ( !lfcbAddedToMfcbList ) {
|
||
SrvDereferenceMfcb( mfcb );
|
||
}
|
||
|
||
SrvDereferenceMfcb( mfcb );
|
||
|
||
//
|
||
// Deallocate the full path name buffer.
|
||
//
|
||
|
||
FREE_HEAP( fullName.Buffer );
|
||
|
||
break;
|
||
|
||
case ShareTypeDisk:
|
||
case ShareTypePipe:
|
||
|
||
//
|
||
// Canonicalize the path name so that it conforms to NT
|
||
// standards.
|
||
//
|
||
// *** Note that this operation allocates space for the name.
|
||
// This space is deallocated after the DoXxxOpen routine
|
||
// returns.
|
||
//
|
||
|
||
status = SrvCanonicalizePathName(
|
||
WorkContext,
|
||
treeConnect->Share,
|
||
NULL,
|
||
SmbFileName,
|
||
EndOfSmbFileName,
|
||
TRUE,
|
||
isUnicode,
|
||
&relativeName
|
||
);
|
||
|
||
if( !NT_SUCCESS( status ) ) {
|
||
|
||
//
|
||
// The path tried to do ..\ to get beyond the share it has
|
||
// accessed.
|
||
//
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "SrvCreateFile: Invalid pathname: %s\n",
|
||
SmbFileName ));
|
||
}
|
||
|
||
return status;
|
||
|
||
}
|
||
|
||
//
|
||
// Form the fully qualified name of the file.
|
||
//
|
||
// *** Note that this operation allocates space for the name.
|
||
// This space is deallocated after the DoXxxOpen routine
|
||
// returns.
|
||
//
|
||
|
||
if ( shareType == ShareTypeDisk ) {
|
||
|
||
#ifdef SLMDBG
|
||
if ( SrvIsSlmStatus( &relativeName ) &&
|
||
SrvIsSlmAccessDisallowed(
|
||
&relativeName,
|
||
treeConnect->Share->RootDirectoryHandle
|
||
) ) {
|
||
return STATUS_ACCESS_DENIED;
|
||
}
|
||
#endif
|
||
|
||
SrvAllocateAndBuildPathName(
|
||
&treeConnect->Share->DosPathName,
|
||
&relativeName,
|
||
NULL,
|
||
&fullName
|
||
);
|
||
|
||
} else {
|
||
|
||
UNICODE_STRING pipePrefix;
|
||
|
||
RtlInitUnicodeString( &pipePrefix, StrSlashPipeSlash );
|
||
|
||
//
|
||
// Check for PIPE pathname prefix.
|
||
//
|
||
|
||
if ( !RtlPrefixUnicodeString(
|
||
&SrvCanonicalNamedPipePrefix,
|
||
&relativeName,
|
||
TRUE
|
||
) ) {
|
||
IF_DEBUG(SMB_ERRORS) {
|
||
KdPrint(( "SrvCreateFile: Invalid pipe pathname: %s\n",
|
||
SmbFileName ));
|
||
}
|
||
|
||
if ( !isUnicode ) {
|
||
RtlFreeUnicodeString( &relativeName );
|
||
}
|
||
|
||
return STATUS_OBJECT_PATH_SYNTAX_BAD;
|
||
}
|
||
|
||
//
|
||
// Delete PIPE\ prefix from file path
|
||
//
|
||
|
||
pipeRelativeName.Buffer = (PWSTR)( (PCHAR)relativeName.Buffer +
|
||
SrvCanonicalNamedPipePrefix.Length );
|
||
pipeRelativeName.Length = relativeName.Length -
|
||
SrvCanonicalNamedPipePrefix.Length;
|
||
pipeRelativeName.MaximumLength = pipeRelativeName.Length;
|
||
|
||
if( WorkContext->Endpoint->RemapPipeNames || treeConnect->RemapPipeNames ) {
|
||
|
||
//
|
||
// The RemapPipeNames flag is set, so remap the pipe name
|
||
// to "$$\<server>\<pipe name>".
|
||
//
|
||
// Note: this operation allocates space for pipeRelativeName.
|
||
//
|
||
status = RemapPipeName(
|
||
&WorkContext->Endpoint->TransportAddress,
|
||
treeConnect->RemapPipeNames ? &treeConnect->ServerName : NULL ,
|
||
&pipeRelativeName,
|
||
&pipeRelativeNameAllocated
|
||
);
|
||
|
||
if( !NT_SUCCESS( status ) ) {
|
||
if ( !isUnicode ) {
|
||
RtlFreeUnicodeString( &relativeName );
|
||
}
|
||
return status;
|
||
}
|
||
}
|
||
|
||
SrvAllocateAndBuildPathName(
|
||
&pipePrefix,
|
||
&pipeRelativeName,
|
||
NULL,
|
||
&fullName
|
||
);
|
||
|
||
//
|
||
// If this is a compatibility mode or FCB mode open, map
|
||
// it to a normal non-shared open.
|
||
//
|
||
|
||
if ( SmbDesiredAccess == SMB_DA_FCB_MASK ||
|
||
(SmbDesiredAccess & SMB_DA_SHARE_MASK) ==
|
||
SMB_DA_SHARE_COMPATIBILITY ) {
|
||
|
||
SmbDesiredAccess = SMB_DA_ACCESS_READ_WRITE |
|
||
SMB_DA_SHARE_EXCLUSIVE;
|
||
}
|
||
|
||
}
|
||
|
||
if ( fullName.Buffer == NULL ) {
|
||
|
||
//
|
||
// Unable to allocate heap for the full name.
|
||
//
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "SrvCreateFile: Unable to allocate heap for "
|
||
"full path name\n" ));
|
||
}
|
||
|
||
if ( !isUnicode ) {
|
||
RtlFreeUnicodeString( &relativeName );
|
||
}
|
||
|
||
if( pipeRelativeNameAllocated ) {
|
||
FREE_HEAP( pipeRelativeName.Buffer );
|
||
}
|
||
|
||
return STATUS_INSUFF_SERVER_RESOURCES;
|
||
}
|
||
|
||
attributes = caseInsensitive ? OBJ_CASE_INSENSITIVE : 0;
|
||
|
||
if ( WorkContext->ProcessingCount == 2) {
|
||
|
||
HANDLE fileHandle;
|
||
OBJECT_ATTRIBUTES objectAttributes;
|
||
IO_STATUS_BLOCK ioStatusBlock;
|
||
|
||
//
|
||
// This is the second time through, so we must be in a blocking
|
||
// thread. Do a blocking open of the file to force an oplock
|
||
// break. Then close the handle and fall through to the normal
|
||
// open path.
|
||
//
|
||
// We must do the blocking open without holding the MFCB
|
||
// lock, because this lock can be acquired during oplock
|
||
// break, resulting in deadlock.
|
||
//
|
||
|
||
SrvInitializeObjectAttributes_U(
|
||
&objectAttributes,
|
||
&relativeName,
|
||
attributes,
|
||
NULL,
|
||
NULL
|
||
);
|
||
|
||
status = SrvIoCreateFile(
|
||
WorkContext,
|
||
&fileHandle,
|
||
GENERIC_READ,
|
||
&objectAttributes,
|
||
&ioStatusBlock,
|
||
NULL,
|
||
0,
|
||
FILE_SHARE_VALID_FLAGS,
|
||
FILE_OPEN,
|
||
0,
|
||
NULL,
|
||
0,
|
||
CreateFileTypeNone,
|
||
NULL, // ExtraCreateParameters
|
||
0,
|
||
WorkContext->TreeConnect->Share
|
||
);
|
||
|
||
if ( NT_SUCCESS( status ) ) {
|
||
SRVDBG_CLAIM_HANDLE( fileHandle, "FIL", 9, 0 );
|
||
SRVDBG_RELEASE_HANDLE( fileHandle, "FIL", 16, 0 );
|
||
SrvNtClose( fileHandle, TRUE );
|
||
}
|
||
|
||
}
|
||
|
||
//
|
||
// Scan the Master File Table to see if the named file is already
|
||
// open. We can do the scan with a shared lock, but we must have an
|
||
// exclusive lock to modify the table. Start out shared, assuming the
|
||
// file is already open.
|
||
//
|
||
|
||
mfcb = SrvFindMfcb( &fullName, caseInsensitive, &mfcbLock, &hashValue, WorkContext );
|
||
|
||
if ( mfcb == NULL ) {
|
||
|
||
//
|
||
// There is no MFCB for this file. Create one.
|
||
//
|
||
|
||
mfcb = SrvCreateMfcb( &fullName, WorkContext, hashValue );
|
||
|
||
if ( mfcb == NULL ) {
|
||
|
||
//
|
||
// Failure to add open file instance to MFT.
|
||
//
|
||
|
||
if( mfcbLock ) {
|
||
RELEASE_LOCK( mfcbLock );
|
||
}
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "SrvCreateFile: Unable to allocate MFCB\n" ));
|
||
}
|
||
|
||
FREE_HEAP( fullName.Buffer );
|
||
|
||
if ( !isUnicode ) {
|
||
RtlFreeUnicodeString( &relativeName );
|
||
}
|
||
|
||
if( pipeRelativeNameAllocated ) {
|
||
FREE_HEAP( pipeRelativeName.Buffer );
|
||
}
|
||
|
||
return STATUS_INSUFF_SERVER_RESOURCES;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Increment the MFCB reference count. See the note at the beginning of this routine.
|
||
//
|
||
mfcb->BlockHeader.ReferenceCount++;
|
||
UPDATE_REFERENCE_HISTORY( mfcb, FALSE );
|
||
|
||
//
|
||
// Grab the MFCB-based lock to serialize opens of the same file
|
||
// and release the MFCB list lock.
|
||
//
|
||
nonpagedMfcb = mfcb->NonpagedMfcb;
|
||
RELEASE_LOCK( mfcbLock );
|
||
ACQUIRE_LOCK( &nonpagedMfcb->Lock );
|
||
|
||
//
|
||
// Call an appropriate routine to actually do the open.
|
||
//
|
||
|
||
openRetries = SrvSharingViolationRetryCount;
|
||
|
||
start_retry:
|
||
|
||
if ( SmbDesiredAccess == SMB_DA_FCB_MASK ) {
|
||
|
||
//
|
||
// This is an FCB open.
|
||
//
|
||
|
||
status = DoFcbOpen(
|
||
&rfcb,
|
||
mfcb,
|
||
WorkContext,
|
||
&WorkContext->Irp->IoStatus,
|
||
SmbFileAttributes,
|
||
SmbOpenFunction,
|
||
SmbAllocationSize,
|
||
&relativeName,
|
||
EaBuffer,
|
||
EaLength,
|
||
EaErrorOffset,
|
||
&lfcbAddedToMfcbList
|
||
);
|
||
|
||
} else if ( (SmbDesiredAccess & SMB_DA_SHARE_MASK) ==
|
||
SMB_DA_SHARE_COMPATIBILITY ) {
|
||
|
||
//
|
||
// This is a compatibility mode open.
|
||
//
|
||
|
||
status = DoCompatibilityOpen(
|
||
&rfcb,
|
||
mfcb,
|
||
WorkContext,
|
||
&WorkContext->Irp->IoStatus,
|
||
SmbDesiredAccess,
|
||
SmbFileAttributes,
|
||
SmbOpenFunction,
|
||
SmbAllocationSize,
|
||
&relativeName,
|
||
EaBuffer,
|
||
EaLength,
|
||
EaErrorOffset,
|
||
&lfcbAddedToMfcbList,
|
||
RequestedOplockType
|
||
);
|
||
|
||
} else {
|
||
|
||
//
|
||
// This is a normal sharing mode open.
|
||
//
|
||
|
||
status = DoNormalOpen(
|
||
&rfcb,
|
||
mfcb,
|
||
WorkContext,
|
||
&WorkContext->Irp->IoStatus,
|
||
SmbDesiredAccess,
|
||
SmbFileAttributes,
|
||
SmbOpenFunction,
|
||
SmbAllocationSize,
|
||
shareType == ShareTypePipe ?
|
||
&pipeRelativeName : &relativeName,
|
||
EaBuffer,
|
||
EaLength,
|
||
EaErrorOffset,
|
||
&lfcbAddedToMfcbList,
|
||
RequestedOplockType
|
||
);
|
||
|
||
}
|
||
|
||
//
|
||
// Retry if sharing violation and we are in the blocking thread.
|
||
//
|
||
|
||
if ( (WorkContext->ProcessingCount == 2) &&
|
||
(status == STATUS_SHARING_VIOLATION) &&
|
||
(shareType == ShareTypeDisk) &&
|
||
(openRetries-- > 0) ) {
|
||
|
||
//
|
||
// Release the mfcb lock so that a close might slip through.
|
||
//
|
||
|
||
RELEASE_LOCK( &nonpagedMfcb->Lock );
|
||
|
||
(VOID) KeDelayExecutionThread(
|
||
KernelMode,
|
||
FALSE,
|
||
&SrvSharingViolationDelay
|
||
);
|
||
|
||
ACQUIRE_LOCK( &nonpagedMfcb->Lock );
|
||
goto start_retry;
|
||
}
|
||
|
||
//
|
||
// Release the Open serialization lock and dereference the MFCB.
|
||
//
|
||
|
||
RELEASE_LOCK( &nonpagedMfcb->Lock );
|
||
|
||
//
|
||
// If DoXxxOpen didn't queue an LFCB to the MFCB, release the
|
||
// extra reference that we added.
|
||
//
|
||
|
||
if ( !lfcbAddedToMfcbList ) {
|
||
SrvDereferenceMfcb( mfcb );
|
||
}
|
||
|
||
SrvDereferenceMfcb( mfcb );
|
||
|
||
//
|
||
// Deallocate the full path name buffer.
|
||
//
|
||
|
||
FREE_HEAP( fullName.Buffer );
|
||
|
||
if ( !isUnicode ) {
|
||
RtlFreeUnicodeString( &relativeName );
|
||
}
|
||
|
||
break;
|
||
|
||
//
|
||
// Default case, illegal device type. This should never happen.
|
||
//
|
||
|
||
default:
|
||
|
||
// !!! Is this an appropriate error return code? Probably no.
|
||
status = STATUS_INVALID_PARAMETER;
|
||
rfcb = NULL;
|
||
|
||
}
|
||
|
||
//
|
||
// Update the statistics database if the open was successful.
|
||
//
|
||
|
||
if ( NT_SUCCESS(status) ) {
|
||
SrvStatistics.TotalFilesOpened++;
|
||
}
|
||
|
||
//
|
||
// Make a pointer to the RFCB accessible to the caller.
|
||
//
|
||
|
||
WorkContext->Parameters2.Open.Rfcb = rfcb;
|
||
|
||
//
|
||
// If there is an oplock break in progress, wait for the oplock
|
||
// break to complete.
|
||
//
|
||
|
||
if ( status == STATUS_OPLOCK_BREAK_IN_PROGRESS ) {
|
||
|
||
NTSTATUS startStatus;
|
||
|
||
//
|
||
// Save the Information from the open, so it doesn't
|
||
// get lost when we re-use the WorkContext->Irp for the
|
||
// oplock processing.
|
||
//
|
||
WorkContext->Parameters2.Open.IosbInformation = WorkContext->Irp->IoStatus.Information;
|
||
|
||
startStatus = SrvStartWaitForOplockBreak(
|
||
WorkContext,
|
||
RestartRoutine,
|
||
0,
|
||
rfcb->Lfcb->FileObject
|
||
);
|
||
|
||
if (!NT_SUCCESS( startStatus ) ) {
|
||
|
||
//
|
||
// The file is oplocked, and we cannot wait for the oplock
|
||
// break to complete. Just close the file, and return the
|
||
// error.
|
||
//
|
||
|
||
SrvCloseRfcb( rfcb );
|
||
status = startStatus;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
if( pipeRelativeNameAllocated ) {
|
||
FREE_HEAP( pipeRelativeName.Buffer );
|
||
}
|
||
|
||
//
|
||
// Return the open status.
|
||
//
|
||
|
||
return status;
|
||
|
||
} // SrvCreateFile
|
||
|
||
|
||
NTSTATUS
|
||
DoNormalOpen(
|
||
OUT PRFCB *Rfcb,
|
||
IN PMFCB Mfcb,
|
||
IN OUT PWORK_CONTEXT WorkContext,
|
||
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
||
IN USHORT SmbDesiredAccess,
|
||
IN USHORT SmbFileAttributes,
|
||
IN USHORT SmbOpenFunction,
|
||
IN ULONG SmbAllocationSize,
|
||
IN PUNICODE_STRING RelativeName,
|
||
IN PVOID EaBuffer OPTIONAL,
|
||
IN ULONG EaLength,
|
||
OUT PULONG EaErrorOffset OPTIONAL,
|
||
OUT PBOOLEAN LfcbAddedToMfcbList,
|
||
IN OPLOCK_TYPE RequestedOplockType
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes a normal sharing mode open.
|
||
|
||
*** The MFCB lock must be held on entry to this routine; the lock
|
||
remains held on exit.
|
||
|
||
Arguments:
|
||
|
||
Rfcb - A pointer to a pointer to an RFCB that will point to the
|
||
newly-created RFCB.
|
||
|
||
Mfcb - A pointer to the MFCB for this file.
|
||
|
||
WorkContext - Work context block for the operation.
|
||
|
||
IoStatusBlock - A pointer to an IO status block.
|
||
|
||
SmbDesiredAccess - The desired access in SMB protocol format.
|
||
|
||
SmbFileAttributes - File attributes in SMB protocol format.
|
||
|
||
SmbOpenFunction - Open function in SMB protocol format.
|
||
|
||
SmbAllocationSize - Allocation size for new files.
|
||
|
||
RelativeName - The share-relative name of the file being opened.
|
||
|
||
EaBuffer - Optional pointer to a full EA list to pass to SrvIoCreateFile.
|
||
|
||
EaLength - Length of the EA buffer.
|
||
|
||
EaErrorOffset - Optional pointer to the location in which to write
|
||
the offset to the EA that caused an error.
|
||
|
||
LfcbAddedToMfcbList - Pointer to a boolean that will be set to TRUE if
|
||
an lfcb is added to the mfcb list of lfcbs. FALSE, otherwise.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Indicates what occurred.
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS status;
|
||
NTSTATUS completionStatus;
|
||
|
||
HANDLE fileHandle;
|
||
|
||
OBJECT_ATTRIBUTES objectAttributes;
|
||
ULONG attributes;
|
||
|
||
LARGE_INTEGER allocationSize;
|
||
ULONG fileAttributes;
|
||
BOOLEAN directory;
|
||
ULONG shareAccess;
|
||
ULONG createDisposition;
|
||
ULONG createOptions;
|
||
ACCESS_MASK desiredAccess;
|
||
PSHARE fileShare = NULL;
|
||
|
||
UCHAR errorClass = SMB_ERR_CLASS_DOS;
|
||
USHORT error = 0;
|
||
|
||
PAGED_CODE( );
|
||
|
||
*LfcbAddedToMfcbList = FALSE;
|
||
|
||
//
|
||
// Map the desired access from SMB terms to NT terms.
|
||
//
|
||
|
||
status = MapDesiredAccess( SmbDesiredAccess, &desiredAccess );
|
||
if ( !NT_SUCCESS(status) ) {
|
||
return status;
|
||
}
|
||
#ifdef SLMDBG
|
||
if ( SrvIsSlmStatus( RelativeName ) ||
|
||
SrvIsTempSlmStatus( RelativeName ) ) {
|
||
desiredAccess |= GENERIC_READ;
|
||
}
|
||
#endif
|
||
|
||
//
|
||
// Map the share mode from SMB terms to NT terms.
|
||
//
|
||
|
||
status = MapShareAccess( SmbDesiredAccess, &shareAccess );
|
||
if ( !NT_SUCCESS(status) ) {
|
||
return status;
|
||
}
|
||
|
||
//
|
||
// We're going to open this file relative to the root directory
|
||
// of the share. Load up the necessary fields in the object
|
||
// attributes structure.
|
||
//
|
||
|
||
if ( WorkContext->RequestHeader->Flags & SMB_FLAGS_CASE_INSENSITIVE ) {
|
||
attributes = OBJ_CASE_INSENSITIVE;
|
||
} else if ( WorkContext->Session->UsingUppercasePaths ) {
|
||
attributes = OBJ_CASE_INSENSITIVE;
|
||
} else {
|
||
attributes = 0L;
|
||
}
|
||
|
||
if ( WorkContext->TreeConnect->Share->ShareType == ShareTypePipe ) {
|
||
SrvInitializeObjectAttributes_U(
|
||
&objectAttributes,
|
||
RelativeName,
|
||
attributes,
|
||
SrvNamedPipeHandle,
|
||
NULL
|
||
);
|
||
} else {
|
||
|
||
fileShare = WorkContext->TreeConnect->Share;
|
||
|
||
SrvInitializeObjectAttributes_U(
|
||
&objectAttributes,
|
||
RelativeName,
|
||
attributes,
|
||
NULL,
|
||
NULL
|
||
);
|
||
}
|
||
|
||
//
|
||
// Set block size according to the AllocationSize in the request SMB.
|
||
//
|
||
|
||
allocationSize.QuadPart = SmbAllocationSize;
|
||
|
||
//
|
||
// Get the value for fileAttributes.
|
||
//
|
||
|
||
SRV_SMB_ATTRIBUTES_TO_NT(
|
||
SmbFileAttributes,
|
||
&directory,
|
||
&fileAttributes
|
||
);
|
||
|
||
//
|
||
// Set createDisposition parameter from OpenFunction.
|
||
//
|
||
|
||
status = MapOpenFunction( SmbOpenFunction, &createDisposition );
|
||
|
||
//
|
||
// OS/2 expects that if it creates a file with an allocation size,
|
||
// the end of file pointer will be the same as that allocation size.
|
||
// Therefore, the server is expected to set EOF to the allocation
|
||
// size on creating a file. However, this requires write access,
|
||
// so if the client is creating a file with an allocation size, give
|
||
// him write access. Only do this if creating a file; if this is
|
||
// a "create or open" operation, don't do this, as it could cause
|
||
// an extraneuos audit.
|
||
//
|
||
|
||
if ( SmbAllocationSize != 0 && createDisposition == FILE_CREATE ) {
|
||
desiredAccess |= GENERIC_WRITE;
|
||
}
|
||
|
||
//
|
||
// Set createOptions parameter.
|
||
//
|
||
|
||
if ( SmbDesiredAccess & SMB_DA_WRITE_THROUGH ) {
|
||
createOptions = FILE_WRITE_THROUGH | FILE_NON_DIRECTORY_FILE;
|
||
} else {
|
||
createOptions = FILE_NON_DIRECTORY_FILE;
|
||
}
|
||
|
||
if ( (SmbGetAlignedUshort( &WorkContext->RequestHeader->Flags2 ) &
|
||
SMB_FLAGS2_KNOWS_EAS) == 0) {
|
||
|
||
//
|
||
// This guy does not know eas
|
||
//
|
||
|
||
createOptions |= FILE_NO_EA_KNOWLEDGE;
|
||
}
|
||
|
||
//
|
||
// Set the caching hints flags.
|
||
//
|
||
|
||
status = MapCacheHints( SmbDesiredAccess, &createOptions );
|
||
|
||
//
|
||
// Check to see if there is a cached handle for the file.
|
||
//
|
||
|
||
if ( (createDisposition == FILE_OPEN) ||
|
||
(createDisposition == FILE_CREATE) ||
|
||
(createDisposition == FILE_OPEN_IF) ) {
|
||
|
||
ASSERT( *LfcbAddedToMfcbList == FALSE );
|
||
|
||
IF_DEBUG(FILE_CACHE) {
|
||
KdPrint(( "SrvCreateFile: checking for cached rfcb for %wZ\n", RelativeName ));
|
||
}
|
||
if ( SrvFindCachedRfcb(
|
||
WorkContext,
|
||
Mfcb,
|
||
desiredAccess,
|
||
shareAccess,
|
||
createDisposition,
|
||
createOptions,
|
||
RequestedOplockType,
|
||
&status ) ) {
|
||
|
||
IF_DEBUG(FILE_CACHE) {
|
||
KdPrint(( "SrvCreateFile: FindCachedRfcb = TRUE, status = %x, rfcb = %p\n",
|
||
status, WorkContext->Rfcb ));
|
||
}
|
||
|
||
IoStatusBlock->Information = FILE_OPENED;
|
||
|
||
return status;
|
||
}
|
||
|
||
IF_DEBUG(FILE_CACHE) {
|
||
KdPrint(( "SrvCreateFile: FindCachedRfcb = FALSE; do it the slow way\n" ));
|
||
}
|
||
}
|
||
|
||
//
|
||
// Call SrvIoCreateFile to create or open the file. (We call
|
||
// SrvIoCreateFile, rather than NtOpenFile, in order to get user-mode
|
||
// access checking.)
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoNormalOpen: Opening file %wZ\n", RelativeName ));
|
||
}
|
||
|
||
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpenAttempts );
|
||
|
||
//
|
||
// Ensure the EaBuffer is correctly formatted. Since we are a kernel mode
|
||
// component, the Io subsystem does not check it for us.
|
||
//
|
||
if( ARGUMENT_PRESENT( EaBuffer ) ) {
|
||
status = IoCheckEaBufferValidity( (PFILE_FULL_EA_INFORMATION)EaBuffer, EaLength, EaErrorOffset );
|
||
} else {
|
||
status = STATUS_SUCCESS;
|
||
}
|
||
|
||
if( NT_SUCCESS( status ) ) {
|
||
|
||
createOptions |= FILE_COMPLETE_IF_OPLOCKED;
|
||
|
||
status = SrvIoCreateFile(
|
||
WorkContext,
|
||
&fileHandle,
|
||
desiredAccess,
|
||
&objectAttributes,
|
||
IoStatusBlock,
|
||
&allocationSize,
|
||
fileAttributes,
|
||
shareAccess,
|
||
createDisposition,
|
||
createOptions,
|
||
EaBuffer,
|
||
EaLength,
|
||
CreateFileTypeNone,
|
||
NULL, // ExtraCreateParameters
|
||
IO_FORCE_ACCESS_CHECK,
|
||
fileShare
|
||
);
|
||
}
|
||
|
||
//
|
||
// If we got sharing violation and this is a disk file, and this is
|
||
// the first open attempt, setup for a blocking open attempt. If the
|
||
// file is batch oplocked, the non-blocking open would fail, and the
|
||
// oplock will not break.
|
||
//
|
||
|
||
if ( status == STATUS_SHARING_VIOLATION &&
|
||
WorkContext->ProcessingCount == 1 &&
|
||
WorkContext->TreeConnect->Share->ShareType == ShareTypeDisk ) {
|
||
|
||
WorkContext->Parameters2.Open.TemporaryOpen = TRUE;
|
||
}
|
||
|
||
//
|
||
// If the user didn't have this permission, update the statistics
|
||
// database.
|
||
//
|
||
|
||
if ( status == STATUS_ACCESS_DENIED ) {
|
||
SrvStatistics.AccessPermissionErrors++;
|
||
}
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
|
||
//
|
||
// The open failed.
|
||
//
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "DoNormalOpen: SrvIoCreateFile failed, file = %wZ, status = %X, Info = 0x%p\n",
|
||
objectAttributes.ObjectName,
|
||
status, (PVOID)IoStatusBlock->Information ));
|
||
}
|
||
|
||
//
|
||
// Set the error offset if needed.
|
||
//
|
||
|
||
if ( ARGUMENT_PRESENT(EaErrorOffset) &&
|
||
status == STATUS_INVALID_EA_NAME ) {
|
||
*EaErrorOffset = (ULONG)IoStatusBlock->Information;
|
||
IoStatusBlock->Information = 0;
|
||
}
|
||
|
||
return status;
|
||
|
||
}
|
||
|
||
SRVDBG_CLAIM_HANDLE( fileHandle, "FIL", 10, 0 );
|
||
|
||
//
|
||
// The open was successful. Attempt to allocate structures to
|
||
// represent the open. If any errors occur, CompleteOpen does full
|
||
// cleanup, including closing the file.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoNormalOpen: Open of %wZ succeeded, file handle: 0x%p\n",
|
||
RelativeName, fileHandle ));
|
||
}
|
||
|
||
completionStatus = CompleteOpen(
|
||
Rfcb,
|
||
Mfcb,
|
||
WorkContext,
|
||
NULL,
|
||
fileHandle,
|
||
NULL,
|
||
shareAccess,
|
||
createOptions,
|
||
FALSE,
|
||
FALSE,
|
||
LfcbAddedToMfcbList
|
||
);
|
||
|
||
//
|
||
// Return the "interesting" status code. If CompleteOpen() succeeds
|
||
// return the open status. If it fails, it will clean up the open
|
||
// file, and we return a failure status.
|
||
//
|
||
|
||
if ( !NT_SUCCESS( completionStatus ) ) {
|
||
return completionStatus;
|
||
} else {
|
||
return status;
|
||
}
|
||
|
||
} // DoNormalOpen
|
||
|
||
|
||
NTSTATUS
|
||
DoCompatibilityOpen(
|
||
OUT PRFCB *Rfcb,
|
||
IN PMFCB Mfcb,
|
||
IN OUT PWORK_CONTEXT WorkContext,
|
||
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
||
IN USHORT SmbDesiredAccess,
|
||
IN USHORT SmbFileAttributes,
|
||
IN USHORT SmbOpenFunction,
|
||
IN ULONG SmbAllocationSize,
|
||
IN PUNICODE_STRING RelativeName,
|
||
IN PVOID EaBuffer OPTIONAL,
|
||
IN ULONG EaLength,
|
||
OUT PULONG EaErrorOffset OPTIONAL,
|
||
OUT PBOOLEAN LfcbAddedToMfcbList,
|
||
IN OPLOCK_TYPE RequestedOplockType
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes a compatibility mode open.
|
||
|
||
*** The MFCB lock must be held on entry to this routine; the lock
|
||
remains held on exit.
|
||
|
||
Arguments:
|
||
|
||
Rfcb - A pointer to a pointer to an RFCB that will point to the
|
||
newly-created RFCB.
|
||
|
||
Mfcb - A pointer to the MFCB for this file.
|
||
|
||
WorkContext - Work context block for the operation.
|
||
|
||
IoStatusBlock - A pointer to an IO status block.
|
||
|
||
SmbDesiredAccess - The desired access in SMB protocol format.
|
||
|
||
SmbFileAttributes - File attributes in SMB protocol format.
|
||
|
||
SmbOpenFunction - Open function in SMB protocol format.
|
||
|
||
SmbAllocationSize - Allocation size for new files.
|
||
|
||
RelativeName - The share-relative name of the file being opened.
|
||
|
||
EaBuffer - Optional pointer to a full EA list to pass to SrvIoCreateFile.
|
||
|
||
EaLength - Length of the EA buffer.
|
||
|
||
EaErrorOffset - Optional pointer to the location in which to write
|
||
the offset to the EA that caused an error.
|
||
|
||
LfcbAddedToMfcbList - Pointer to a boolean that will be set to TRUE if
|
||
an lfcb is added to the mfcb list of lfcbs.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Indicates what occurred.
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS status;
|
||
NTSTATUS completionStatus;
|
||
|
||
PLFCB lfcb;
|
||
|
||
HANDLE fileHandle;
|
||
|
||
OBJECT_ATTRIBUTES objectAttributes;
|
||
ULONG attributes;
|
||
|
||
LARGE_INTEGER allocationSize;
|
||
ULONG fileAttributes;
|
||
BOOLEAN directory;
|
||
ULONG createDisposition;
|
||
ULONG createOptions;
|
||
ACCESS_MASK desiredAccess;
|
||
USHORT smbOpenMode;
|
||
|
||
PAGED_CODE( );
|
||
|
||
*LfcbAddedToMfcbList = FALSE;
|
||
|
||
//
|
||
// Map the desired access from SMB terms to NT terms.
|
||
//
|
||
|
||
status = MapDesiredAccess( SmbDesiredAccess, &desiredAccess );
|
||
if ( !NT_SUCCESS(status) ) {
|
||
return status;
|
||
}
|
||
|
||
//
|
||
// Set createDisposition parameter from OpenFunction.
|
||
//
|
||
|
||
status = MapOpenFunction( SmbOpenFunction, &createDisposition );
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
return status;
|
||
}
|
||
|
||
//
|
||
// Set createOptions parameter.
|
||
//
|
||
|
||
if ( SmbDesiredAccess & SMB_DA_WRITE_THROUGH ) {
|
||
createOptions = FILE_WRITE_THROUGH | FILE_NON_DIRECTORY_FILE;
|
||
} else {
|
||
createOptions = FILE_NON_DIRECTORY_FILE;
|
||
}
|
||
|
||
if ( (SmbGetAlignedUshort( &WorkContext->RequestHeader->Flags2 ) &
|
||
SMB_FLAGS2_KNOWS_EAS) == 0) {
|
||
|
||
//
|
||
// This guy does not know eas
|
||
//
|
||
|
||
createOptions |= FILE_NO_EA_KNOWLEDGE;
|
||
}
|
||
|
||
//
|
||
// We're going to open this file relative to the root directory
|
||
// of the share. Load up the necessary fields in the object
|
||
// attributes structure.
|
||
//
|
||
|
||
if ( WorkContext->RequestHeader->Flags & SMB_FLAGS_CASE_INSENSITIVE ) {
|
||
attributes = OBJ_CASE_INSENSITIVE;
|
||
} else if ( WorkContext->Session->UsingUppercasePaths ) {
|
||
attributes = OBJ_CASE_INSENSITIVE;
|
||
} else {
|
||
attributes = 0L;
|
||
}
|
||
|
||
SrvInitializeObjectAttributes_U(
|
||
&objectAttributes,
|
||
RelativeName,
|
||
attributes,
|
||
NULL,
|
||
NULL
|
||
);
|
||
|
||
if ( Mfcb->ActiveRfcbCount > 0 ) {
|
||
|
||
//
|
||
// The named file is already opened by the server. If the client
|
||
// specified that it didn't want to open an existing file,
|
||
// reject this open.
|
||
//
|
||
|
||
if ( createDisposition == FILE_CREATE ) {
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoCompatibilityOpen: Compatibility open of %wZ rejected; wants to create\n", RelativeName ));
|
||
}
|
||
|
||
return STATUS_OBJECT_NAME_COLLISION;
|
||
}
|
||
|
||
//
|
||
// If the existing open is not a compatibility mode open, then
|
||
// we try to map the new open into a normal sharing mode. If
|
||
// that works, we attempt a normal open. If it doesn't work, we
|
||
// reject the new open. If the existing open is a compatibility
|
||
// mode open by this session, we just add a new RFCB. If it's a
|
||
// compatibility mode open by a different session, we reject
|
||
// this open.
|
||
//
|
||
|
||
if ( !Mfcb->CompatibilityOpen ) {
|
||
|
||
//
|
||
// The named file is open, but not in compatibility mode.
|
||
// Determine whether this should be mapped from a
|
||
// compatibility mode open to a normal sharing mode open.
|
||
//
|
||
|
||
smbOpenMode = SmbDesiredAccess;
|
||
|
||
if ( MapCompatibilityOpen( RelativeName, &smbOpenMode ) ) {
|
||
|
||
//
|
||
// The open has been mapped to a normal sharing mode.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoCompatibilityOpen: Mapped compatibility open of %wZ to normal open\n", RelativeName ));
|
||
}
|
||
|
||
return DoNormalOpen(
|
||
Rfcb,
|
||
Mfcb,
|
||
WorkContext,
|
||
IoStatusBlock,
|
||
smbOpenMode,
|
||
SmbFileAttributes,
|
||
SmbOpenFunction,
|
||
SmbAllocationSize,
|
||
RelativeName,
|
||
EaBuffer,
|
||
EaLength,
|
||
EaErrorOffset,
|
||
LfcbAddedToMfcbList,
|
||
RequestedOplockType
|
||
);
|
||
|
||
}
|
||
|
||
//
|
||
// The open was not mapped away from compatibility mode.
|
||
// Because the file is already open for normal sharing, this
|
||
// open request must be rejected.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoCompatibilityOpen: Compatibility open of %wZ rejected; already open in normal mode\n",
|
||
RelativeName ));
|
||
}
|
||
|
||
status = STATUS_SHARING_VIOLATION;
|
||
goto sharing_violation;
|
||
|
||
} // if ( !Mfcb->CompatibilityOpen )
|
||
|
||
//
|
||
// The named file is open in compatibility mode. Get a pointer
|
||
// to the LFCB for the open. Determine whether the requesting
|
||
// session is the one that did the original open.
|
||
//
|
||
// Normally there will only be one LFCB linked to a
|
||
// compatibility mode MFCB. However, it is possible for there
|
||
// to briefly be multiple LFCBs. When an LFCB is in the process
|
||
// of closing, the ActiveRfcbCount will be 0, so a new open will
|
||
// be treated as the first open of the MFCB, and there will be
|
||
// two LFCBs linked to the MFCB. There can actually be more
|
||
// than two LFCBs linked if the rundown of the closing LFCBs
|
||
// takes some time. So the find "the" LFCB for the open, we go
|
||
// to the tail of the MFCB's list.
|
||
//
|
||
|
||
lfcb = CONTAINING_RECORD( Mfcb->LfcbList.Blink, LFCB, MfcbListEntry );
|
||
|
||
if ( lfcb->Session != WorkContext->Session ) {
|
||
|
||
//
|
||
// A different session has the file open in compatibility
|
||
// mode. Reject this open request.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoCompatibilityOpen: Compatibility open of %wZ rejected; already open in compatibility mode\n",
|
||
RelativeName ));
|
||
}
|
||
|
||
status = STATUS_SHARING_VIOLATION;
|
||
goto sharing_violation;
|
||
}
|
||
|
||
//
|
||
// If this request is asking for more access than could be
|
||
// obtained when the file was originally opened, reject this
|
||
// open.
|
||
//
|
||
|
||
if ( !NT_SUCCESS(IoCheckDesiredAccess(
|
||
&desiredAccess,
|
||
lfcb->GrantedAccess )) ) {
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoCompatibilityOpen: Duplicate compatibility open of %wZ rejected; access denied\n", RelativeName ));
|
||
}
|
||
|
||
return STATUS_ACCESS_DENIED;
|
||
}
|
||
|
||
//
|
||
// The client has access. Allocate a new RFCB and link it into
|
||
// the existing LFCB. If any errors occur, CompleteOpen does
|
||
// full cleanup.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoCompatibilityOpen: Duplicate compatibility open of %wZ accepted", RelativeName ));
|
||
}
|
||
|
||
IoStatusBlock->Information = FILE_OPENED;
|
||
|
||
status = CompleteOpen(
|
||
Rfcb,
|
||
Mfcb,
|
||
WorkContext,
|
||
lfcb,
|
||
NULL,
|
||
&desiredAccess,
|
||
0, // ShareAccess
|
||
createOptions,
|
||
TRUE,
|
||
FALSE,
|
||
LfcbAddedToMfcbList
|
||
);
|
||
|
||
if( NT_SUCCESS( status ) &&
|
||
( createDisposition == FILE_OVERWRITE ||
|
||
createDisposition == FILE_OVERWRITE_IF)
|
||
) {
|
||
//
|
||
// The file was successfully opened, and the client wants it
|
||
// truncated. We need to do it here by hand since we
|
||
// didn't actually call the filesystem to open the file and it
|
||
// therefore never had a chance to truncate the file if the
|
||
// open modes requested it.
|
||
//
|
||
LARGE_INTEGER zero;
|
||
IO_STATUS_BLOCK ioStatusBlock;
|
||
|
||
zero.QuadPart = 0;
|
||
NtSetInformationFile( lfcb->FileHandle,
|
||
&ioStatusBlock,
|
||
&zero,
|
||
sizeof( zero ),
|
||
FileEndOfFileInformation
|
||
);
|
||
}
|
||
|
||
return status;
|
||
|
||
} // if ( mfcb->ActiveRfcbCount > 0 )
|
||
|
||
//
|
||
// The file is not already open (by the server, at least).
|
||
// Determine whether this should be mapped from a compatibility mode
|
||
// open to a normal sharing mode open.
|
||
//
|
||
|
||
smbOpenMode = SmbDesiredAccess;
|
||
|
||
if ( MapCompatibilityOpen( RelativeName, &smbOpenMode ) ) {
|
||
|
||
//
|
||
// The open has been mapped to a normal sharing mode.
|
||
//
|
||
|
||
return DoNormalOpen(
|
||
Rfcb,
|
||
Mfcb,
|
||
WorkContext,
|
||
IoStatusBlock,
|
||
smbOpenMode,
|
||
SmbFileAttributes,
|
||
SmbOpenFunction,
|
||
SmbAllocationSize,
|
||
RelativeName,
|
||
EaBuffer,
|
||
EaLength,
|
||
EaErrorOffset,
|
||
LfcbAddedToMfcbList,
|
||
RequestedOplockType
|
||
);
|
||
|
||
}
|
||
|
||
//
|
||
// The open was not mapped away from compatibility mode. Attempt to
|
||
// open the file for exclusive access.
|
||
//
|
||
// *** We try to open the file for the most access we'll ever need.
|
||
// This is because we fold multiple compatibility opens by the
|
||
// same client into a single local open. The client may open
|
||
// the file first for readonly access, then for read/write
|
||
// access. Because the local open is exclusive, we can't open
|
||
// again on the second remote open. We try to get Delete
|
||
// access, in case the client tries to delete the file while
|
||
// it's open.
|
||
//
|
||
|
||
//
|
||
// Set block size according to the AllocationSize in the request SMB.
|
||
//
|
||
|
||
allocationSize.QuadPart = SmbAllocationSize;
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoCompatibilityOpen: Opening file %wZ\n", RelativeName ));
|
||
}
|
||
|
||
//
|
||
// Get the value for fileAttributes.
|
||
//
|
||
|
||
SRV_SMB_ATTRIBUTES_TO_NT(
|
||
SmbFileAttributes,
|
||
&directory,
|
||
&fileAttributes
|
||
);
|
||
|
||
//
|
||
// Try to open the file for Read/Write/Delete access.
|
||
//
|
||
|
||
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpenAttempts );
|
||
|
||
//
|
||
// Ensure the EaBuffer is correctly formatted. Since we are a kernel mode
|
||
// component, the Io subsystem does not check it for us.
|
||
//
|
||
if( ARGUMENT_PRESENT( EaBuffer ) ) {
|
||
status = IoCheckEaBufferValidity( (PFILE_FULL_EA_INFORMATION)EaBuffer, EaLength, EaErrorOffset );
|
||
} else {
|
||
status = STATUS_SUCCESS;
|
||
}
|
||
|
||
if( NT_SUCCESS( status ) ) {
|
||
|
||
createOptions |= FILE_COMPLETE_IF_OPLOCKED;
|
||
|
||
status = SrvIoCreateFile(
|
||
WorkContext,
|
||
&fileHandle,
|
||
GENERIC_READ | GENERIC_WRITE | DELETE, // DesiredAccess
|
||
&objectAttributes,
|
||
IoStatusBlock,
|
||
&allocationSize,
|
||
fileAttributes,
|
||
0L, // ShareAccess
|
||
createDisposition,
|
||
createOptions,
|
||
EaBuffer,
|
||
EaLength,
|
||
CreateFileTypeNone,
|
||
NULL, // ExtraCreateParameters
|
||
IO_FORCE_ACCESS_CHECK,
|
||
WorkContext->TreeConnect->Share
|
||
);
|
||
}
|
||
|
||
|
||
if ( status == STATUS_ACCESS_DENIED ) {
|
||
|
||
//
|
||
// The client doesn't have Read/Write/Delete access to the file.
|
||
// Try for Read/Write access.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoCompatibilityOpen: r/w/d access denied.\n" ));
|
||
}
|
||
|
||
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpenAttempts );
|
||
|
||
status = SrvIoCreateFile(
|
||
WorkContext,
|
||
&fileHandle,
|
||
GENERIC_READ | GENERIC_WRITE, // DesiredAccess
|
||
&objectAttributes,
|
||
IoStatusBlock,
|
||
&allocationSize,
|
||
fileAttributes,
|
||
0L, // ShareAccess
|
||
createDisposition,
|
||
createOptions,
|
||
EaBuffer,
|
||
EaLength,
|
||
CreateFileTypeNone,
|
||
NULL, // ExtraPipeCreateParameters
|
||
IO_FORCE_ACCESS_CHECK,
|
||
WorkContext->TreeConnect->Share
|
||
);
|
||
|
||
|
||
if ( status == STATUS_ACCESS_DENIED ) {
|
||
|
||
//
|
||
// The client doesn't have Read/Write access to the file.
|
||
// Try Read or Write access, as appropriate.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoCompatibilityOpen: r/w access denied.\n" ));
|
||
}
|
||
|
||
if ( (SmbDesiredAccess & SMB_DA_ACCESS_MASK) ==
|
||
SMB_DA_ACCESS_READ ) {
|
||
|
||
//
|
||
// !!! Should this be mapped to a normal sharing mode?
|
||
// Note that we already tried to map into normal
|
||
// mode once, but that failed. (With the current
|
||
// mapping algorithm, we can't get here unless soft
|
||
// compatibility is disabled.)
|
||
//
|
||
|
||
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpenAttempts );
|
||
|
||
status = SrvIoCreateFile(
|
||
WorkContext,
|
||
&fileHandle,
|
||
GENERIC_READ, // DesiredAccess
|
||
&objectAttributes,
|
||
IoStatusBlock,
|
||
&allocationSize,
|
||
fileAttributes,
|
||
0L, // ShareAccess
|
||
createDisposition,
|
||
createOptions,
|
||
EaBuffer,
|
||
EaLength,
|
||
CreateFileTypeNone,
|
||
NULL, // ExtraCreateParameters
|
||
IO_FORCE_ACCESS_CHECK,
|
||
WorkContext->TreeConnect->Share
|
||
);
|
||
|
||
} else if ( (SmbDesiredAccess & SMB_DA_ACCESS_MASK) ==
|
||
SMB_DA_ACCESS_WRITE ) {
|
||
|
||
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpenAttempts );
|
||
|
||
status = SrvIoCreateFile(
|
||
WorkContext,
|
||
&fileHandle,
|
||
GENERIC_WRITE, // DesiredAccess
|
||
&objectAttributes,
|
||
IoStatusBlock,
|
||
&allocationSize,
|
||
fileAttributes,
|
||
0L, // ShareAccess
|
||
createDisposition,
|
||
createOptions,
|
||
EaBuffer,
|
||
EaLength,
|
||
CreateFileTypeNone,
|
||
NULL, // NamedPipeCreateParameters
|
||
IO_FORCE_ACCESS_CHECK,
|
||
WorkContext->TreeConnect->Share
|
||
);
|
||
|
||
}
|
||
|
||
//
|
||
// If the user didn't have this permission, update the
|
||
// statistics database.
|
||
//
|
||
|
||
if ( status == STATUS_ACCESS_DENIED ) {
|
||
SrvStatistics.AccessPermissionErrors++;
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
//
|
||
// If we got sharing violation, just get a handle so that we can wait
|
||
// for an oplock break.
|
||
//
|
||
|
||
sharing_violation:
|
||
//
|
||
// If we got sharing violation and this is a disk file, and this is
|
||
// the first open attempt, setup for a blocking open attempt. If the
|
||
// file is batch oplocked, the non-blocking open would fail, and the
|
||
// oplock will not break.
|
||
//
|
||
|
||
if ( status == STATUS_SHARING_VIOLATION &&
|
||
WorkContext->ProcessingCount == 1 &&
|
||
WorkContext->TreeConnect->Share->ShareType == ShareTypeDisk ) {
|
||
|
||
WorkContext->Parameters2.Open.TemporaryOpen = TRUE;
|
||
}
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
|
||
//
|
||
// All of the open attempts failed.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoCompatibilityOpen: all opens failed; status = %X\n",
|
||
status ));
|
||
}
|
||
|
||
//
|
||
// Set the error offset if needed.
|
||
//
|
||
|
||
if ( ARGUMENT_PRESENT(EaErrorOffset) &&
|
||
status == STATUS_INVALID_EA_NAME ) {
|
||
*EaErrorOffset = (ULONG)IoStatusBlock->Information;
|
||
IoStatusBlock->Information = 0;
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
SRVDBG_CLAIM_HANDLE( fileHandle, "FIL", 11, 0 );
|
||
|
||
//
|
||
// The file has been successfully opened for exclusive access, with
|
||
// at least as much desired access as requested by the client.
|
||
// Attempt to allocate structures to represent the open. If any
|
||
// errors occur, CompleteOpen does full cleanup, including closing
|
||
// the file.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoCompatibilityOpen: Open of %wZ succeeded, file handle: 0x%p\n", RelativeName, fileHandle ));
|
||
}
|
||
|
||
completionStatus = CompleteOpen(
|
||
Rfcb,
|
||
Mfcb,
|
||
WorkContext,
|
||
NULL,
|
||
fileHandle,
|
||
&desiredAccess,
|
||
0, // ShareAccess
|
||
createOptions,
|
||
TRUE,
|
||
FALSE,
|
||
LfcbAddedToMfcbList
|
||
);
|
||
|
||
//
|
||
// Return the "interesting" status code. If CompleteOpen() succeeds
|
||
// return the open status. If it fails, it will clean up the open
|
||
// file, and we return a failure status.
|
||
//
|
||
|
||
if ( !NT_SUCCESS( completionStatus ) ) {
|
||
return completionStatus;
|
||
} else {
|
||
return status;
|
||
}
|
||
|
||
} // DoCompatibilityOpen
|
||
|
||
|
||
NTSTATUS
|
||
DoFcbOpen(
|
||
OUT PRFCB *Rfcb,
|
||
IN PMFCB Mfcb,
|
||
IN OUT PWORK_CONTEXT WorkContext,
|
||
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
||
IN USHORT SmbFileAttributes,
|
||
IN USHORT SmbOpenFunction,
|
||
IN ULONG SmbAllocationSize,
|
||
IN PUNICODE_STRING RelativeName,
|
||
IN PVOID EaBuffer OPTIONAL,
|
||
IN ULONG EaLength,
|
||
OUT PULONG EaErrorOffset OPTIONAL,
|
||
OUT PBOOLEAN LfcbAddedToMfcbList
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes an FCB open.
|
||
|
||
*** The MFCB lock must be held on entry to this routine; the lock
|
||
remains held on exit.
|
||
|
||
Arguments:
|
||
|
||
Rfcb - A pointer to a pointer to an RFCB that will point to the
|
||
newly-created RFCB.
|
||
|
||
Mfcb - A pointer to the MFCB for this file
|
||
|
||
WorkContext - Work context block for the operation.
|
||
|
||
IoStatusBlock - A pointer to an IO status block.
|
||
|
||
SmbFileAttributes - File attributes in SMB protocol format.
|
||
|
||
SmbOpenFunction - Open function in SMB protocol format.
|
||
|
||
SmbAllocationSize - Allocation size for new files.
|
||
|
||
RelativeName - The share-relative name of the file being opened.
|
||
|
||
EaBuffer - Optional pointer to a full EA list to pass to SrvIoCreateFile.
|
||
|
||
EaLength - Length of the EA buffer.
|
||
|
||
EaErrorOffset - Optional pointer to the location in which to write
|
||
the offset to the EA that caused an error.
|
||
|
||
LfcbAddedToMfcbList - Pointer to a boolean that will be set to TRUE if
|
||
an lfcb is added to the mfcb list of lfcbs.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Indicates what occurred.
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS status;
|
||
NTSTATUS completionStatus;
|
||
|
||
PLIST_ENTRY lfcbEntry;
|
||
PLIST_ENTRY rfcbEntry;
|
||
|
||
PRFCB rfcb;
|
||
PPAGED_RFCB pagedRfcb;
|
||
PLFCB lfcb;
|
||
|
||
HANDLE fileHandle;
|
||
|
||
OBJECT_ATTRIBUTES objectAttributes;
|
||
ULONG attributes;
|
||
|
||
LARGE_INTEGER allocationSize;
|
||
ULONG fileAttributes;
|
||
BOOLEAN directory;
|
||
ULONG createOptions;
|
||
ULONG createDisposition;
|
||
ULONG shareAccess;
|
||
BOOLEAN compatibilityOpen;
|
||
|
||
PAGED_CODE( );
|
||
|
||
*LfcbAddedToMfcbList = FALSE;
|
||
|
||
//
|
||
// Set createDisposition parameter from OpenFunction.
|
||
//
|
||
|
||
status = MapOpenFunction( SmbOpenFunction, &createDisposition );
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
return status;
|
||
}
|
||
|
||
//
|
||
// Set createOptions parameter.
|
||
//
|
||
|
||
if ( (SmbGetAlignedUshort( &WorkContext->RequestHeader->Flags2 ) &
|
||
SMB_FLAGS2_KNOWS_EAS) == 0) {
|
||
|
||
//
|
||
// This guy does not know eas
|
||
//
|
||
|
||
createOptions = FILE_NON_DIRECTORY_FILE |
|
||
FILE_NO_EA_KNOWLEDGE;
|
||
} else {
|
||
|
||
createOptions = FILE_NON_DIRECTORY_FILE;
|
||
}
|
||
|
||
//
|
||
// We're going to open this file relative to the root directory
|
||
// of the share. Load up the necessary fields in the object
|
||
// attributes structure.
|
||
//
|
||
|
||
if ( WorkContext->RequestHeader->Flags & SMB_FLAGS_CASE_INSENSITIVE ) {
|
||
attributes = OBJ_CASE_INSENSITIVE;
|
||
} else if ( WorkContext->Session->UsingUppercasePaths ) {
|
||
attributes = OBJ_CASE_INSENSITIVE;
|
||
} else {
|
||
attributes = 0L;
|
||
}
|
||
|
||
SrvInitializeObjectAttributes_U(
|
||
&objectAttributes,
|
||
RelativeName,
|
||
attributes,
|
||
NULL,
|
||
NULL
|
||
);
|
||
|
||
createOptions |= FILE_COMPLETE_IF_OPLOCKED;
|
||
|
||
if ( Mfcb->ActiveRfcbCount > 0 ) {
|
||
|
||
//
|
||
// The named file is already open by the server. If the client
|
||
// specified that it didn't want to open an existing file,
|
||
// reject this open.
|
||
//
|
||
|
||
if ( createDisposition == FILE_CREATE ) {
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoFcbOpen: FCB open of %wZ rejected; wants to create\n", RelativeName ));
|
||
}
|
||
|
||
return STATUS_OBJECT_NAME_COLLISION;
|
||
}
|
||
|
||
//
|
||
// If the requesting session already has the file open in FCB
|
||
// mode, fold this open into the existing open by returning a
|
||
// pointer to the existing RFCB.
|
||
//
|
||
// *** Multiple FCB opens are folded together because the client
|
||
// may send only one close; that single close closes all FCB
|
||
// opens by the client.
|
||
//
|
||
|
||
for ( lfcbEntry = Mfcb->LfcbList.Flink;
|
||
lfcbEntry != &Mfcb->LfcbList;
|
||
lfcbEntry = lfcbEntry->Flink ) {
|
||
|
||
lfcb = CONTAINING_RECORD( lfcbEntry, LFCB, MfcbListEntry );
|
||
|
||
if ( lfcb->Session == WorkContext->Session ) {
|
||
|
||
//
|
||
// This LFCB is owned by the requesting session. Check
|
||
// for RFCBs opened in FCB mode.
|
||
//
|
||
|
||
for ( rfcbEntry = lfcb->RfcbList.Flink;
|
||
rfcbEntry != &lfcb->RfcbList;
|
||
rfcbEntry = rfcbEntry->Flink ) {
|
||
|
||
pagedRfcb = CONTAINING_RECORD(
|
||
rfcbEntry,
|
||
PAGED_RFCB,
|
||
LfcbListEntry
|
||
);
|
||
|
||
rfcb = pagedRfcb->PagedHeader.NonPagedBlock;
|
||
if ( (pagedRfcb->FcbOpenCount != 0) &&
|
||
(GET_BLOCK_STATE(rfcb) == BlockStateActive) ) {
|
||
|
||
//
|
||
// The requesting session already has the file
|
||
// open in FCB mode. Rather than reopening the
|
||
// file, or even linking a new RFCB off the
|
||
// LFCB, we just return a pointer to the
|
||
// existing RFCB.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoFcbOpen: FCB open of %wZ accepted; duplicates FCB open\n", RelativeName ));
|
||
}
|
||
|
||
SrvReferenceRfcb( rfcb );
|
||
|
||
pagedRfcb->FcbOpenCount++;
|
||
|
||
IoStatusBlock->Information = FILE_OPENED;
|
||
|
||
WorkContext->Rfcb = rfcb;
|
||
*Rfcb = rfcb;
|
||
|
||
return STATUS_SUCCESS;
|
||
|
||
} // if ( rfcb->FcbOpenCount != 0 )
|
||
|
||
} // for ( rfcbEntry = lfcb->RfcbList.Flink; ...
|
||
|
||
} // if ( lfcb->Session == WorkContext->Session )
|
||
|
||
} // for ( lfcbEntry = mfcb->LfcbList.Flink; ...
|
||
|
||
//
|
||
// The server has the file open, but the requesting session
|
||
// doesn't already have an FCB open for the file. If the
|
||
// existing open is a compatibility mode open open by this
|
||
// session, we just add a new RFCB. If it's a compatibility
|
||
// mode open by a different session, we reject this open.
|
||
//
|
||
|
||
if ( Mfcb->CompatibilityOpen ) {
|
||
|
||
//
|
||
// The named file is open in compatibility mode. Get a
|
||
// pointer to the LFCB for the open. Determine whether the
|
||
// requesting session is the one that did the original open.
|
||
//
|
||
// Normally there will only be one LFCB linked to a
|
||
// compatibility mode MFCB. However, it is possible for
|
||
// there to briefly be multiple LFCBs. When an LFCB is in
|
||
// the process of closing, the ActiveRfcbCount will be 0, so
|
||
// a new open will be treated as the first open of the MFCB,
|
||
// and there will be two LFCBs linked to the MFCB. There
|
||
// can actually be more than two LFCBs linked if the rundown
|
||
// of the closing LFCBs takes some time. So the find "the"
|
||
// LFCB for the open, we go to the tail of the MFCB's list.
|
||
//
|
||
|
||
lfcb = CONTAINING_RECORD( Mfcb->LfcbList.Blink, LFCB, MfcbListEntry );
|
||
|
||
if ( lfcb->Session != WorkContext->Session ) {
|
||
|
||
//
|
||
// A different session has the file open in
|
||
// compatibility mode. Reject this open request.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoFcbOpen: FCB open of %wZ rejected; already open in compatibility mode\n",
|
||
RelativeName ));
|
||
}
|
||
|
||
return STATUS_SHARING_VIOLATION;
|
||
}
|
||
|
||
//
|
||
// The same client has the file open in compatibility mode.
|
||
// Allocate a new RFCB and link it into the existing LFCB.
|
||
// If any errors occur, CompleteOpen does full cleanup.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoFcbOpen: FCB open of %wZ accepted; duplicates compatibility open\n", RelativeName ));
|
||
}
|
||
|
||
IoStatusBlock->Information = FILE_OPENED;
|
||
|
||
status = CompleteOpen(
|
||
Rfcb,
|
||
Mfcb,
|
||
WorkContext,
|
||
lfcb,
|
||
NULL,
|
||
NULL,
|
||
0, // ShareAccess
|
||
0,
|
||
TRUE,
|
||
TRUE,
|
||
LfcbAddedToMfcbList
|
||
);
|
||
|
||
return status;
|
||
|
||
} // if ( mfcb->CompatibilityOpen )
|
||
|
||
} // if ( mfcb->ActiveRfcbCount > 0 )
|
||
|
||
//
|
||
// Either the file is not already open by the server, or it's open
|
||
// for normal sharing, and not in FCB mode by this session. Because
|
||
// we're supposed to give the client maximum access to the file, we
|
||
// do the following:
|
||
//
|
||
// 1) Try to open the file for read/write/delete, exclusive access.
|
||
// Obviously this will fail if the file is already open. But
|
||
// what we're really trying to find out is what access the client
|
||
// has to the file. If this attempt fails with a sharing
|
||
// violation, then we know the client has write/delete access,
|
||
// but someone else has it open. So we can't get compatibility
|
||
// mode. Therefore, we reject the open. On the other hand, if
|
||
// we get an access denied error, then we know the client can't
|
||
// write/delete the file, so we try again with write access. Of
|
||
// course, this first open could succeed, in which case the
|
||
// client has the file open for read/write in compatibility mode.
|
||
//
|
||
// 2) Try to open the file for read/write, exclusive access. As
|
||
// above, if it fails with a sharing violation, then we know the
|
||
// client has write access, but someone else has it open. So we
|
||
// can't get compatibility mode, and we reject the open. If we
|
||
// get an access denied error, then we know the client can't
|
||
// write the file, so we try again with readonly access. If this
|
||
// open succeeds, the client has the file open for read/write in
|
||
// compatibility mode.
|
||
//
|
||
// 3) If we get here, we know the client can't write to the file,
|
||
// so we try to open the file for readonly, shared access. This
|
||
// no longer a compatibility mode open. If we get any kind of a
|
||
// failure here, we're just out of luck.
|
||
//
|
||
|
||
compatibilityOpen = TRUE;
|
||
|
||
//
|
||
// Set block size according to the AllocationSize in the request SMB.
|
||
//
|
||
|
||
allocationSize.QuadPart = SmbAllocationSize;
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoFcbOpen: Opening file %wZ\n", RelativeName ));
|
||
}
|
||
|
||
//
|
||
// Get the value for fileAttributes.
|
||
//
|
||
|
||
SRV_SMB_ATTRIBUTES_TO_NT(
|
||
SmbFileAttributes,
|
||
&directory,
|
||
&fileAttributes
|
||
);
|
||
|
||
//
|
||
// Try to open the file for Read/Write/Delete access.
|
||
//
|
||
|
||
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpenAttempts );
|
||
|
||
//
|
||
// Ensure the EaBuffer is correctly formatted. Since we are a kernel mode
|
||
// component, the Io subsystem does not check it for us.
|
||
//
|
||
if( ARGUMENT_PRESENT( EaBuffer ) ) {
|
||
status = IoCheckEaBufferValidity( (PFILE_FULL_EA_INFORMATION)EaBuffer, EaLength, EaErrorOffset );
|
||
} else {
|
||
status = STATUS_SUCCESS;
|
||
}
|
||
|
||
if( NT_SUCCESS( status ) ) {
|
||
status = SrvIoCreateFile(
|
||
WorkContext,
|
||
&fileHandle,
|
||
GENERIC_READ | GENERIC_WRITE | DELETE, // DesiredAccess
|
||
&objectAttributes,
|
||
IoStatusBlock,
|
||
&allocationSize,
|
||
fileAttributes,
|
||
0L, // ShareAccess
|
||
createDisposition,
|
||
createOptions,
|
||
EaBuffer,
|
||
EaLength,
|
||
CreateFileTypeNone,
|
||
NULL, // ExtraCreateParameters
|
||
IO_FORCE_ACCESS_CHECK,
|
||
WorkContext->TreeConnect->Share
|
||
);
|
||
}
|
||
|
||
|
||
if ( status == STATUS_ACCESS_DENIED ) {
|
||
|
||
//
|
||
// The client doesn't have Read/Write/Delete access to the file.
|
||
// Try for Read/Write access.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoFcbOpen: r/w/d access denied.\n" ));
|
||
}
|
||
|
||
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpenAttempts );
|
||
|
||
status = SrvIoCreateFile(
|
||
WorkContext,
|
||
&fileHandle,
|
||
GENERIC_READ | GENERIC_WRITE, // DesiredAccess
|
||
&objectAttributes,
|
||
IoStatusBlock,
|
||
&allocationSize,
|
||
fileAttributes,
|
||
0L, // ShareAccess
|
||
createDisposition,
|
||
createOptions,
|
||
EaBuffer,
|
||
EaLength,
|
||
CreateFileTypeNone,
|
||
NULL, // ExtraCreateParameters
|
||
IO_FORCE_ACCESS_CHECK,
|
||
WorkContext->TreeConnect->Share
|
||
);
|
||
|
||
|
||
if ( status == STATUS_ACCESS_DENIED ) {
|
||
|
||
//
|
||
// The client doesn't have Read/Write access to the file.
|
||
// Try Read access. If soft compatibility mapping is
|
||
// enabled, use SHARE=READ and don't call this a
|
||
// compatibility mode open.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoFcbOpen: r/w access denied.\n" ));
|
||
}
|
||
|
||
shareAccess = 0;
|
||
if ( SrvEnableSoftCompatibility ) {
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoFcbOpen: FCB open of %wZ mapped to normal open\n", RelativeName ));
|
||
}
|
||
shareAccess = FILE_SHARE_READ;
|
||
compatibilityOpen = FALSE;
|
||
}
|
||
|
||
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpenAttempts );
|
||
|
||
status = SrvIoCreateFile(
|
||
WorkContext,
|
||
&fileHandle,
|
||
GENERIC_READ, // DesiredAccess
|
||
&objectAttributes,
|
||
IoStatusBlock,
|
||
&allocationSize,
|
||
fileAttributes,
|
||
shareAccess,
|
||
createDisposition,
|
||
createOptions,
|
||
EaBuffer,
|
||
EaLength,
|
||
CreateFileTypeNone,
|
||
NULL, // ExtraCreateParameters
|
||
IO_FORCE_ACCESS_CHECK,
|
||
WorkContext->TreeConnect->Share
|
||
);
|
||
|
||
|
||
//
|
||
// If the user didn't have this permission, update the
|
||
// statistics database.
|
||
//
|
||
|
||
if ( status == STATUS_ACCESS_DENIED ) {
|
||
SrvStatistics.AccessPermissionErrors++;
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
//
|
||
// If we got sharing violation and this is a disk file, and this is
|
||
// the first open attempt, setup for a blocking open attempt. If the
|
||
// file is batch oplocked, the non-blocking open would fail, and the
|
||
// oplock will not break.
|
||
//
|
||
|
||
if ( status == STATUS_SHARING_VIOLATION &&
|
||
WorkContext->ProcessingCount == 1 &&
|
||
WorkContext->TreeConnect->Share->ShareType == ShareTypeDisk ) {
|
||
|
||
WorkContext->Parameters2.Open.TemporaryOpen = TRUE;
|
||
}
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
|
||
//
|
||
// All of the open attempts failed.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoFcbOpen: all opens failed; status = %X\n",
|
||
status ));
|
||
}
|
||
|
||
//
|
||
// Set the error offset if needed.
|
||
//
|
||
|
||
if ( ARGUMENT_PRESENT(EaErrorOffset) ) {
|
||
*EaErrorOffset = (ULONG)IoStatusBlock->Information;
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
SRVDBG_CLAIM_HANDLE( fileHandle, "FIL", 12, 0 );
|
||
|
||
//
|
||
// The file has been successfully opened. Attempt to allocate
|
||
// structures to represent the open. If any errors occur,
|
||
// CompleteOpen does full cleanup, including closing the file.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "DoFcbOpen: Open of %wZ succeeded, file handle: 0x%p\n", RelativeName, fileHandle ));
|
||
}
|
||
|
||
completionStatus = CompleteOpen(
|
||
Rfcb,
|
||
Mfcb,
|
||
WorkContext,
|
||
NULL,
|
||
fileHandle,
|
||
NULL,
|
||
0, // ShareAccess
|
||
0,
|
||
compatibilityOpen,
|
||
TRUE,
|
||
LfcbAddedToMfcbList
|
||
);
|
||
|
||
//
|
||
// Return the "interesting" status code. If CompleteOpen() succeeds
|
||
// return the open status. If it fails, it will clean up the open
|
||
// file, and we return a failure status.
|
||
//
|
||
|
||
if ( !NT_SUCCESS( completionStatus ) ) {
|
||
return completionStatus;
|
||
} else {
|
||
return status;
|
||
}
|
||
|
||
} // DoFcbOpen
|
||
|
||
|
||
PTABLE_ENTRY
|
||
FindAndClaimFileTableEntry (
|
||
IN PCONNECTION Connection,
|
||
OUT PSHORT FidIndex
|
||
)
|
||
{
|
||
PTABLE_HEADER tableHeader;
|
||
SHORT fidIndex;
|
||
PTABLE_ENTRY entry;
|
||
KIRQL oldIrql;
|
||
|
||
UNLOCKABLE_CODE( 8FIL );
|
||
|
||
tableHeader = &Connection->FileTable;
|
||
|
||
ACQUIRE_SPIN_LOCK( &Connection->SpinLock, &oldIrql );
|
||
|
||
if ( tableHeader->FirstFreeEntry == -1
|
||
&&
|
||
SrvGrowTable(
|
||
tableHeader,
|
||
SrvInitialFileTableSize,
|
||
SrvMaxFileTableSize,
|
||
NULL ) == FALSE
|
||
) {
|
||
|
||
RELEASE_SPIN_LOCK( &Connection->SpinLock, oldIrql );
|
||
|
||
return NULL;
|
||
}
|
||
|
||
//
|
||
// Remove the FID slot from the free list, but don't set its owner
|
||
// and sequence number yet.
|
||
//
|
||
|
||
fidIndex = tableHeader->FirstFreeEntry;
|
||
|
||
entry = &tableHeader->Table[fidIndex];
|
||
|
||
tableHeader->FirstFreeEntry = entry->NextFreeEntry;
|
||
DEBUG entry->NextFreeEntry = -2;
|
||
if ( tableHeader->LastFreeEntry == fidIndex ) {
|
||
tableHeader->LastFreeEntry = -1;
|
||
}
|
||
|
||
RELEASE_SPIN_LOCK( &Connection->SpinLock, oldIrql );
|
||
|
||
*FidIndex = fidIndex;
|
||
return entry;
|
||
|
||
} // FindAndClaimFileTableEntry
|
||
|
||
|
||
NTSTATUS
|
||
CompleteOpen (
|
||
OUT PRFCB *Rfcb,
|
||
IN PMFCB Mfcb,
|
||
IN OUT PWORK_CONTEXT WorkContext,
|
||
IN PLFCB ExistingLfcb OPTIONAL,
|
||
IN HANDLE FileHandle OPTIONAL,
|
||
IN PACCESS_MASK RemoteGrantedAccess OPTIONAL,
|
||
IN ULONG ShareAccess,
|
||
IN ULONG FileMode,
|
||
IN BOOLEAN CompatibilityOpen,
|
||
IN BOOLEAN FcbOpen,
|
||
OUT PBOOLEAN LfcbAddedToMfcbList
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Completes structure allocation, initialization, and linking after
|
||
a successful open. Updates Master File Table as appropriate.
|
||
Adds entry to connection's file table.
|
||
|
||
*** The MFCB lock must be held on entry to this routine; the lock
|
||
remains held on exit.
|
||
|
||
Arguments:
|
||
|
||
Rfcb - A pointer to a pointer to an RFCB that will point to the
|
||
newly-created RFCB.
|
||
|
||
Mfcb - A pointer to the MFCB for this file.
|
||
|
||
WorkContext - Work context block for the operation.
|
||
|
||
ExistingLfcb - Optional address of an existing Local File Control
|
||
Block. Specified when folding a duplicate compatibility mode
|
||
open into a single local open.
|
||
|
||
FileHandle - Optional file handle obtained from SrvIoCreateFile.
|
||
Ignored when ExistingLfcb is specified.
|
||
|
||
RemoteGrantedAccess - Optional granted access to be stored in new
|
||
RFCB. If not specified, granted access from LFCB (i.e., access
|
||
obtained on local open) is used.
|
||
|
||
FileMode - Same value specified as CreateOptions on SrvIoCreateFile
|
||
call. Indicates whether client wants writethrough mode.
|
||
|
||
CompatibilityOpen - TRUE if this is a compatibility mode open.
|
||
|
||
FcbOpen - TRUE if this is an FCB open.
|
||
|
||
LfcbAddedToMfcbList - Pointer to a boolean that will be set to TRUE if
|
||
an lfcb is added to the mfcb list of lfcbs.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Indicates what occurred.
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS status;
|
||
|
||
PRFCB rfcb;
|
||
PPAGED_RFCB pagedRfcb;
|
||
PLFCB newLfcb;
|
||
PLFCB lfcb;
|
||
BOOLEAN rfcbLinkedToLfcb;
|
||
|
||
PFILE_OBJECT fileObject;
|
||
|
||
OBJECT_HANDLE_INFORMATION handleInformation;
|
||
|
||
PCONNECTION connection;
|
||
PTABLE_ENTRY entry;
|
||
SHORT fidIndex;
|
||
|
||
ULONG pid;
|
||
|
||
PAGED_CODE( );
|
||
|
||
//
|
||
// Initialize various fields for the error handler.
|
||
//
|
||
|
||
rfcb = NULL;
|
||
newLfcb = NULL;
|
||
rfcbLinkedToLfcb = FALSE;
|
||
fileObject = NULL;
|
||
*LfcbAddedToMfcbList = FALSE;
|
||
|
||
//
|
||
// Allocate an RFCB.
|
||
//
|
||
|
||
SrvAllocateRfcb( &rfcb, WorkContext );
|
||
|
||
if ( rfcb == NULL ) {
|
||
|
||
ULONG length = sizeof( RFCB );
|
||
|
||
//
|
||
// Unable to allocate RFCB. Return an error to the client.
|
||
//
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "CompleteOpen: Unable to allocate RFCB\n" ));
|
||
}
|
||
|
||
status = STATUS_INSUFF_SERVER_RESOURCES;
|
||
goto error_exit;
|
||
|
||
}
|
||
|
||
pagedRfcb = rfcb->PagedRfcb;
|
||
|
||
//
|
||
// If no existing LFCB address was passed in (i.e., if this is not a
|
||
// duplicate compatibility mode open), allocate and initialize a new
|
||
// LFCB.
|
||
//
|
||
|
||
if ( ARGUMENT_PRESENT( ExistingLfcb ) ) {
|
||
|
||
ASSERT( CompatibilityOpen );
|
||
ASSERT( ExistingLfcb->CompatibilityOpen );
|
||
|
||
lfcb = ExistingLfcb;
|
||
|
||
} else {
|
||
|
||
PFAST_IO_DISPATCH fastIoDispatch;
|
||
|
||
SrvAllocateLfcb( &newLfcb, WorkContext );
|
||
|
||
if ( newLfcb == NULL ) {
|
||
|
||
//
|
||
// Unable to allocate LFCB. Return an error to the client.
|
||
//
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "CompleteOpen: Unable to allocate LFCB\n" ));
|
||
}
|
||
|
||
status = STATUS_INSUFF_SERVER_RESOURCES;
|
||
goto error_exit;
|
||
|
||
}
|
||
|
||
lfcb = newLfcb;
|
||
|
||
//
|
||
// Get a pointer to the file object, so that we can directly
|
||
// build IRPs for asynchronous operations (read and write).
|
||
// Also, get the granted access mask, so that we can prevent the
|
||
// client from doing things that it isn't allowed to do.
|
||
//
|
||
// *** Note that the granted access on the local open may allow
|
||
// more access than was requested on the remote open.
|
||
// That's why the RFCB has its own granted access field.
|
||
//
|
||
|
||
status = ObReferenceObjectByHandle(
|
||
FileHandle,
|
||
0,
|
||
NULL,
|
||
KernelMode,
|
||
(PVOID *)&fileObject,
|
||
&handleInformation
|
||
);
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
|
||
SrvLogServiceFailure( SRV_SVC_OB_REF_BY_HANDLE, status );
|
||
|
||
//
|
||
// This internal error bugchecks the system.
|
||
//
|
||
|
||
INTERNAL_ERROR(
|
||
ERROR_LEVEL_IMPOSSIBLE,
|
||
"CompleteOpen: unable to reference file handle 0x%lx",
|
||
FileHandle,
|
||
NULL
|
||
);
|
||
|
||
goto error_exit;
|
||
|
||
}
|
||
|
||
//
|
||
// Initialize the new LFCB.
|
||
//
|
||
|
||
lfcb->FileHandle = FileHandle;
|
||
lfcb->FileObject = fileObject;
|
||
|
||
lfcb->GrantedAccess = handleInformation.GrantedAccess;
|
||
lfcb->DeviceObject = IoGetRelatedDeviceObject( fileObject );
|
||
|
||
fastIoDispatch = lfcb->DeviceObject->DriverObject->FastIoDispatch;
|
||
if ( fastIoDispatch != NULL ) {
|
||
lfcb->FastIoRead = fastIoDispatch->FastIoRead;
|
||
lfcb->FastIoWrite = fastIoDispatch->FastIoWrite;
|
||
lfcb->FastIoLock = fastIoDispatch->FastIoLock;
|
||
lfcb->FastIoUnlockSingle = fastIoDispatch->FastIoUnlockSingle;
|
||
|
||
//
|
||
// Fill in Mdl calls. If the file system's vector is large enough,
|
||
// we still need to check if one of the routines is specified. But
|
||
// if one is specified they all must be.
|
||
//
|
||
if ((fastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlWriteComplete)) &&
|
||
(fastIoDispatch->MdlRead != NULL)) {
|
||
|
||
lfcb->MdlRead = fastIoDispatch->MdlRead;
|
||
lfcb->MdlReadComplete = fastIoDispatch->MdlReadComplete;
|
||
lfcb->PrepareMdlWrite = fastIoDispatch->PrepareMdlWrite;
|
||
lfcb->MdlWriteComplete = fastIoDispatch->MdlWriteComplete;
|
||
|
||
|
||
} else if( IoGetBaseFileSystemDeviceObject( fileObject ) == lfcb->DeviceObject ) {
|
||
//
|
||
// Otherwise default to the original FsRtl routines if we are right atop
|
||
// a filesystem.
|
||
//
|
||
lfcb->MdlRead = FsRtlMdlReadDev;
|
||
lfcb->MdlReadComplete = FsRtlMdlReadCompleteDev;
|
||
lfcb->PrepareMdlWrite = FsRtlPrepareMdlWriteDev;
|
||
lfcb->MdlWriteComplete = FsRtlMdlWriteCompleteDev;
|
||
} else {
|
||
//
|
||
// Otherwise, make them fail!
|
||
//
|
||
lfcb->MdlRead = SrvFailMdlReadDev;
|
||
lfcb->PrepareMdlWrite = SrvFailPrepareMdlWriteDev;
|
||
}
|
||
|
||
//
|
||
// Fill in Mdl calls, if the file system vector is long enough.
|
||
// For now we will just copy all six compressed routines over,
|
||
// whether they are actually supplied or not (NULL). There are
|
||
// no default routines for these, they are either supported or not.
|
||
//
|
||
|
||
if ((fastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlWriteCompleteCompressed))) {
|
||
|
||
lfcb->FastIoReadCompressed = fastIoDispatch->FastIoReadCompressed;
|
||
lfcb->FastIoWriteCompressed = fastIoDispatch->FastIoWriteCompressed;
|
||
lfcb->MdlReadCompleteCompressed = fastIoDispatch->MdlReadCompleteCompressed;
|
||
lfcb->MdlWriteCompleteCompressed = fastIoDispatch->MdlWriteCompleteCompressed;
|
||
}
|
||
}
|
||
|
||
lfcb->FileMode = FileMode & ~FILE_COMPLETE_IF_OPLOCKED;
|
||
lfcb->CompatibilityOpen = CompatibilityOpen;
|
||
}
|
||
|
||
//
|
||
// Initialize the RFCB.
|
||
//
|
||
|
||
if ( ARGUMENT_PRESENT( RemoteGrantedAccess ) ) {
|
||
rfcb->GrantedAccess = *RemoteGrantedAccess;
|
||
IoCheckDesiredAccess( &rfcb->GrantedAccess, lfcb->GrantedAccess );
|
||
} else {
|
||
rfcb->GrantedAccess = lfcb->GrantedAccess;
|
||
}
|
||
|
||
rfcb->ShareAccess = ShareAccess;
|
||
rfcb->FileMode = lfcb->FileMode;
|
||
rfcb->Mfcb = Mfcb;
|
||
#ifdef SRVCATCH
|
||
rfcb->SrvCatch = Mfcb->SrvCatch;
|
||
#endif
|
||
|
||
//
|
||
// If delete on close was specified, don't attempt to cache this rfcb.
|
||
//
|
||
|
||
if ( (FileMode & FILE_DELETE_ON_CLOSE) != 0 ) {
|
||
rfcb->IsCacheable = FALSE;
|
||
}
|
||
|
||
//
|
||
// Check for granted access
|
||
//
|
||
|
||
//
|
||
// Locks
|
||
//
|
||
|
||
CHECK_FUNCTION_ACCESS(
|
||
rfcb->GrantedAccess,
|
||
IRP_MJ_LOCK_CONTROL,
|
||
IRP_MN_LOCK,
|
||
0,
|
||
&status
|
||
);
|
||
|
||
if ( NT_SUCCESS(status) ) {
|
||
rfcb->LockAccessGranted = TRUE;
|
||
} else {
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "CompleteOpen: Lock IoCheckFunctionAccess failed: "
|
||
"0x%X, GrantedAccess: %lx\n",
|
||
status, rfcb->GrantedAccess ));
|
||
}
|
||
}
|
||
|
||
//
|
||
// Unlocks
|
||
//
|
||
|
||
CHECK_FUNCTION_ACCESS(
|
||
rfcb->GrantedAccess,
|
||
IRP_MJ_LOCK_CONTROL,
|
||
IRP_MN_UNLOCK_SINGLE,
|
||
0,
|
||
&status
|
||
);
|
||
|
||
if ( NT_SUCCESS(status) ) {
|
||
rfcb->UnlockAccessGranted = TRUE;
|
||
} else {
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "CompleteOpen: Unlock IoCheckFunctionAccess failed: "
|
||
"0x%X, GrantedAccess: %lx\n",
|
||
status, rfcb->GrantedAccess ));
|
||
}
|
||
}
|
||
|
||
//
|
||
// Reads
|
||
//
|
||
|
||
CHECK_FUNCTION_ACCESS(
|
||
rfcb->GrantedAccess,
|
||
IRP_MJ_READ,
|
||
0, 0, &status );
|
||
|
||
if ( NT_SUCCESS(status) ) {
|
||
rfcb->ReadAccessGranted = TRUE;
|
||
} else {
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "CompleteOpen: Read IoCheckFunctionAccess failed: "
|
||
"0x%X, GrantedAccess: %lx\n",
|
||
status, rfcb->GrantedAccess ));
|
||
}
|
||
}
|
||
|
||
//
|
||
// Writes
|
||
//
|
||
|
||
if( rfcb->GrantedAccess & FILE_WRITE_DATA ) {
|
||
rfcb->WriteAccessGranted = TRUE;
|
||
}
|
||
if( rfcb->GrantedAccess & FILE_APPEND_DATA ) {
|
||
rfcb->AppendAccessGranted = TRUE;
|
||
|
||
//
|
||
// This hack is required for now. The problem is that clients, given an
|
||
// oplock, will write whole pages to the server. The offset of the page
|
||
// will likely cover the last part of the file, and the server will reject
|
||
// the write. Code needs to be added to the server to ignore the
|
||
// first part of the page. Or we could just not give the client an oplock
|
||
// if append access is granted. For now, we revert to prior NT4 behavior.
|
||
//
|
||
rfcb->WriteAccessGranted = TRUE;
|
||
}
|
||
|
||
//
|
||
// Copy the TID from the tree connect into the RFCB. We do this to
|
||
// reduce the number of indirections we have to take. Save the PID
|
||
// of the remote process that's opening the file. We'll need this
|
||
// if we get a Process Exit SMB.
|
||
//
|
||
|
||
rfcb->Tid = WorkContext->TreeConnect->Tid;
|
||
rfcb->Pid = SmbGetAlignedUshort( &WorkContext->RequestHeader->Pid );
|
||
pid = rfcb->Pid;
|
||
rfcb->Uid = WorkContext->Session->Uid;
|
||
|
||
if ( FcbOpen ) {
|
||
pagedRfcb->FcbOpenCount = 1;
|
||
}
|
||
|
||
if ( WorkContext->Endpoint->IsConnectionless ) {
|
||
rfcb->WriteMpx.FileObject = lfcb->FileObject;
|
||
rfcb->WriteMpx.MpxGlommingAllowed =
|
||
(BOOLEAN)((lfcb->FileObject->Flags & FO_CACHE_SUPPORTED) != 0);
|
||
}
|
||
|
||
//
|
||
// If this is a named pipe, fill in the named pipe specific
|
||
// information. The default mode on open is always byte mode,
|
||
// blocking.
|
||
//
|
||
|
||
rfcb->ShareType = WorkContext->TreeConnect->Share->ShareType;
|
||
|
||
if ( rfcb->ShareType == ShareTypePipe ) {
|
||
rfcb->BlockingModePipe = TRUE;
|
||
rfcb->ByteModePipe = TRUE;
|
||
}
|
||
|
||
//
|
||
// Link the RFCB into the LFCB.
|
||
//
|
||
|
||
SrvInsertTailList( &lfcb->RfcbList, &pagedRfcb->LfcbListEntry );
|
||
rfcb->Lfcb = lfcb;
|
||
lfcb->BlockHeader.ReferenceCount++;
|
||
UPDATE_REFERENCE_HISTORY( lfcb, FALSE );
|
||
lfcb->HandleCount++;
|
||
rfcbLinkedToLfcb = TRUE;
|
||
|
||
//
|
||
// Making a new RFCB visible is a multi-step operation. It must be
|
||
// inserted in the global ordered file list and the containing
|
||
// connection's file table. If the LFCB is not new, it must be
|
||
// inserted in the MFCB's list of LFCBs, and the connection, the
|
||
// session, and the tree connect must all be referenced. We need to
|
||
// make these operations appear atomic, so that the RFCB cannot be
|
||
// accessed elsewhere before we're done setting it up. In order to
|
||
// do this, we hold all necessary locks the entire time we're doing
|
||
// the operations. The locks that are required are:
|
||
//
|
||
// 1) the MFCB lock (which protects the MFCB's LFCB list),
|
||
//
|
||
// 2) the global ordered list lock (which protects the ordered file
|
||
// list),
|
||
//
|
||
// 3) the connection lock (which prevents closing of the
|
||
// connection, the session, and the tree connect), and
|
||
//
|
||
// These locks are taken out in the order listed above, as dictated
|
||
// by lock levels (see lock.h). Note that the MFCB lock is already
|
||
// held on entry to this routine.
|
||
//
|
||
|
||
connection = WorkContext->Connection;
|
||
|
||
ASSERT( ExIsResourceAcquiredExclusiveLite(&RESOURCE_OF(Mfcb->NonpagedMfcb->Lock)) );
|
||
ASSERT( SrvRfcbList.Lock == &SrvOrderedListLock );
|
||
ACQUIRE_LOCK( SrvRfcbList.Lock );
|
||
ACQUIRE_LOCK( &connection->Lock );
|
||
|
||
//
|
||
// We first check all conditions to make sure that we can actually
|
||
// insert this RFCB.
|
||
//
|
||
// Make sure that the tree connect isn't closing.
|
||
//
|
||
|
||
if ( GET_BLOCK_STATE(WorkContext->TreeConnect) != BlockStateActive ) {
|
||
|
||
//
|
||
// The tree connect is closing. Reject the request.
|
||
//
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "CompleteOpen: Tree connect is closing\n" ));
|
||
}
|
||
|
||
status = STATUS_INVALID_PARAMETER;
|
||
goto cant_insert;
|
||
|
||
}
|
||
|
||
//
|
||
// Make sure that the session isn't closing.
|
||
//
|
||
|
||
if ( GET_BLOCK_STATE(WorkContext->Session) != BlockStateActive ) {
|
||
|
||
//
|
||
// The session is closing. Reject the request.
|
||
//
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "CompleteOpen: Session is closing\n" ));
|
||
}
|
||
|
||
status = STATUS_INVALID_PARAMETER;
|
||
goto cant_insert;
|
||
|
||
}
|
||
|
||
//
|
||
// Make sure that the connection isn't closing.
|
||
//
|
||
|
||
connection = WorkContext->Connection;
|
||
|
||
if ( GET_BLOCK_STATE(connection) != BlockStateActive ) {
|
||
|
||
//
|
||
// The connection is closing. Reject the request.
|
||
//
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "CompleteOpen: Connection closing\n" ));
|
||
}
|
||
|
||
status = STATUS_INVALID_PARAMETER;
|
||
goto cant_insert;
|
||
}
|
||
|
||
//
|
||
// Find and claim a FID that can be used for this file.
|
||
//
|
||
|
||
entry = FindAndClaimFileTableEntry( connection, &fidIndex );
|
||
if ( entry == NULL ) {
|
||
|
||
//
|
||
// No free entries in the file table. Reject the request.
|
||
//
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "CompleteOpen: No more FIDs available.\n" ));
|
||
}
|
||
|
||
SrvLogTableFullError( SRV_TABLE_FILE );
|
||
|
||
status = STATUS_OS2_TOO_MANY_OPEN_FILES;
|
||
goto cant_insert;
|
||
}
|
||
|
||
//
|
||
// All conditions have been satisfied. We can now do the things
|
||
// necessary to make the file visible.
|
||
//
|
||
// If this isn't a duplicate open, add this open file instance to
|
||
// the Master File Table.
|
||
//
|
||
|
||
if ( !ARGUMENT_PRESENT( ExistingLfcb ) ) {
|
||
|
||
//
|
||
// Add the new LFCB to the master file's list of open instances.
|
||
// We set LfcbAddedToMfcbList to tell the calling routine that
|
||
// an LFCB has been queued to the MFCB and that the reference
|
||
// count that was previously incremented should not be
|
||
// decremented.
|
||
//
|
||
|
||
*LfcbAddedToMfcbList = TRUE;
|
||
Mfcb->CompatibilityOpen = lfcb->CompatibilityOpen;
|
||
SrvInsertTailList( &Mfcb->LfcbList, &lfcb->MfcbListEntry );
|
||
lfcb->Mfcb = Mfcb;
|
||
|
||
//
|
||
// Point the LFCB to the connection, session, and tree connect,
|
||
// referencing them to account for the open file and therefore
|
||
// prevent deletion.
|
||
//
|
||
|
||
SrvReferenceConnection( connection );
|
||
lfcb->Connection = connection;
|
||
|
||
SrvReferenceSession( WorkContext->Session );
|
||
lfcb->Session = WorkContext->Session;
|
||
|
||
SrvReferenceTreeConnect( WorkContext->TreeConnect );
|
||
lfcb->TreeConnect = WorkContext->TreeConnect;
|
||
|
||
//
|
||
// Increment the count of open files in the session and tree
|
||
// connect. These counts prevent autodisconnecting a session
|
||
// that has open files and are used by server APIs.
|
||
//
|
||
|
||
WorkContext->Session->CurrentFileOpenCount++;
|
||
WorkContext->TreeConnect->CurrentFileOpenCount++;
|
||
|
||
}
|
||
|
||
//
|
||
// Capture the connection pointer in the nonpaged RFCB so that we
|
||
// can find the connection at DPC level.
|
||
//
|
||
|
||
rfcb->Connection = lfcb->Connection;
|
||
|
||
//
|
||
// Insert the RFCB on the global ordered list.
|
||
//
|
||
|
||
SrvInsertEntryOrderedList( &SrvRfcbList, rfcb );
|
||
|
||
//
|
||
// Set the owner and sequence number of the file table slot. Create
|
||
// a FID for the file.
|
||
//
|
||
|
||
entry->Owner = rfcb;
|
||
|
||
INCREMENT_FID_SEQUENCE( entry->SequenceNumber );
|
||
if ( fidIndex == 0 && entry->SequenceNumber == 0 ) {
|
||
INCREMENT_FID_SEQUENCE( entry->SequenceNumber );
|
||
}
|
||
|
||
rfcb->Fid = MAKE_FID( fidIndex, entry->SequenceNumber );
|
||
rfcb->ShiftedFid = rfcb->Fid << 16;
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "CompleteOpen: Found FID. Index = 0x%lx, sequence = 0x%lx\n",
|
||
FID_INDEX( rfcb->Fid ), FID_SEQUENCE( rfcb->Fid ) ));
|
||
}
|
||
|
||
//
|
||
// Release the locks used to make this operation appear atomic.
|
||
//
|
||
// Note that our caller expects us to keep the MFCB lock held.
|
||
//
|
||
|
||
RELEASE_LOCK( &connection->Lock );
|
||
RELEASE_LOCK( SrvRfcbList.Lock );
|
||
|
||
//
|
||
// File successfully opened. Save in the WorkContext block for
|
||
// the followon SMB, if any. Cache the Rfcb.
|
||
//
|
||
|
||
WorkContext->Rfcb = rfcb;
|
||
*Rfcb = rfcb;
|
||
|
||
//
|
||
// Update the MFCB active count.
|
||
//
|
||
|
||
++Mfcb->ActiveRfcbCount;
|
||
|
||
//
|
||
// If this is a pipe, set the client ID for the pipe. If it is a
|
||
// message type named pipe, set the read mode to message mode.
|
||
//
|
||
|
||
if ( rfcb->ShareType == ShareTypePipe ) {
|
||
|
||
//
|
||
// NT clients put the high part of the PID in a reserved
|
||
// location in the SMB header.
|
||
//
|
||
|
||
if ( IS_NT_DIALECT( WorkContext->Connection->SmbDialect ) ) {
|
||
pid = (SmbGetUshort( &WorkContext->RequestHeader->PidHigh )
|
||
<< 16) | pid;
|
||
}
|
||
|
||
(VOID)SrvIssueSetClientProcessRequest(
|
||
lfcb->FileObject,
|
||
&lfcb->DeviceObject,
|
||
connection,
|
||
WorkContext->Session,
|
||
LongToPtr( pid )
|
||
);
|
||
|
||
//
|
||
// Set the read mode.
|
||
//
|
||
|
||
rfcb->ByteModePipe = !SetDefaultPipeMode( FileHandle );
|
||
|
||
}
|
||
|
||
return STATUS_SUCCESS;
|
||
|
||
cant_insert:
|
||
|
||
//
|
||
// Release the locks.
|
||
//
|
||
// Note that our caller expects us to keep the MFCB lock held.
|
||
//
|
||
|
||
RELEASE_LOCK( &connection->Lock );
|
||
RELEASE_LOCK( SrvRfcbList.Lock );
|
||
|
||
error_exit:
|
||
|
||
//
|
||
// Error cleanup. Put things back into their initial state.
|
||
//
|
||
// If the new RFCB was associated with an LFCB, unlink it now.
|
||
//
|
||
|
||
if ( rfcbLinkedToLfcb ) {
|
||
SrvRemoveEntryList(
|
||
&rfcb->Lfcb->RfcbList,
|
||
&pagedRfcb->LfcbListEntry
|
||
);
|
||
|
||
lfcb->BlockHeader.ReferenceCount--;
|
||
UPDATE_REFERENCE_HISTORY( lfcb, TRUE );
|
||
lfcb->HandleCount--;
|
||
}
|
||
|
||
//
|
||
// If the file object was referenced, dereference it.
|
||
//
|
||
|
||
if ( fileObject != NULL ) {
|
||
ObDereferenceObject( fileObject );
|
||
}
|
||
|
||
//
|
||
// If a new LFCB was allocated, free it.
|
||
//
|
||
|
||
if ( newLfcb != NULL ) {
|
||
SrvFreeLfcb( newLfcb, WorkContext->CurrentWorkQueue );
|
||
}
|
||
|
||
//
|
||
// If a new RFCB was allocated, free it.
|
||
//
|
||
|
||
if ( rfcb != NULL ) {
|
||
SrvFreeRfcb( rfcb, WorkContext->CurrentWorkQueue );
|
||
}
|
||
|
||
//
|
||
// If this not a folded compatibility mode open, close the file.
|
||
//
|
||
|
||
if ( !ARGUMENT_PRESENT( ExistingLfcb ) ) {
|
||
SRVDBG_RELEASE_HANDLE( FileHandle, "FIL", 17, 0 );
|
||
SrvNtClose( FileHandle, TRUE );
|
||
}
|
||
|
||
//
|
||
// Indicate failure.
|
||
//
|
||
|
||
*Rfcb = NULL;
|
||
|
||
return status;
|
||
|
||
} // CompleteOpen
|
||
|
||
|
||
BOOLEAN SRVFASTCALL
|
||
MapCompatibilityOpen(
|
||
IN PUNICODE_STRING FileName,
|
||
IN OUT PUSHORT SmbDesiredAccess
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Determines whether a compatibility mode open can be mapped into
|
||
normal sharing mode.
|
||
|
||
Arguments:
|
||
|
||
FileName - The name of the file being accessed
|
||
|
||
SmbDesiredAccess - On input, the desired access specified in the
|
||
received SMB. On output, the share mode portion of this field
|
||
is updated if the open is mapped to normal sharing.
|
||
|
||
Return Value:
|
||
|
||
BOOLEAN - TRUE if the open has been mapped to normal sharing.
|
||
|
||
--*/
|
||
|
||
{
|
||
PAGED_CODE( );
|
||
|
||
//
|
||
// If soft compatibility is not enabled then reject the mapping
|
||
//
|
||
if( !SrvEnableSoftCompatibility ) {
|
||
|
||
IF_SMB_DEBUG( OPEN_CLOSE2 ) {
|
||
KdPrint(( "MapCompatibilityOpen: "
|
||
"SrvEnableSoftCompatibility is FALSE\n" ));
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// If the client is opening one of the following reserved suffixes, be lenient
|
||
//
|
||
if( FileName->Length > 4 * sizeof( WCHAR ) ) {
|
||
|
||
LPWSTR periodp;
|
||
|
||
periodp = FileName->Buffer + (FileName->Length / sizeof( WCHAR ) ) - 4;
|
||
|
||
if( (*periodp++ == L'.') &&
|
||
(_wcsicmp( periodp, L"EXE" ) == 0 ||
|
||
_wcsicmp( periodp, L"DLL" ) == 0 ||
|
||
_wcsicmp( periodp, L"SYM" ) == 0 ||
|
||
_wcsicmp( periodp, L"COM" ) == 0 ) ) {
|
||
|
||
//
|
||
// This is a readonly open of one of the above file types.
|
||
// Map to DENY_NONE
|
||
//
|
||
|
||
IF_SMB_DEBUG( OPEN_CLOSE2 ) {
|
||
KdPrint(( "MapCompatibilityOpen: %wZ mapped to DENY_NONE\n", FileName ));
|
||
}
|
||
|
||
*SmbDesiredAccess |= SMB_DA_SHARE_DENY_NONE;
|
||
return TRUE;
|
||
}
|
||
}
|
||
|
||
//
|
||
// The filename does not end in one of the special suffixes -- map
|
||
// it to DENY_WRITE if the client is asking for just read permissions.
|
||
//
|
||
if( (*SmbDesiredAccess & SMB_DA_ACCESS_MASK) == SMB_DA_ACCESS_READ) {
|
||
IF_SMB_DEBUG( OPEN_CLOSE2 ) {
|
||
KdPrint(( "MapCompatibilityOpen: %wZ mapped to DENY_WRITE\n", FileName ));
|
||
}
|
||
*SmbDesiredAccess |= SMB_DA_SHARE_DENY_WRITE;
|
||
return TRUE;
|
||
}
|
||
|
||
IF_SMB_DEBUG( OPEN_CLOSE2 ) {
|
||
KdPrint(( "MapCompatibilityOpen: %wZ not mapped, DesiredAccess %X\n", FileName, *SmbDesiredAccess ));
|
||
}
|
||
|
||
return FALSE;
|
||
} // MapCompatibilityOpen
|
||
|
||
|
||
NTSTATUS SRVFASTCALL
|
||
MapDesiredAccess(
|
||
IN USHORT SmbDesiredAccess,
|
||
OUT PACCESS_MASK NtDesiredAccess
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Maps a desired access specification from SMB form to NT form.
|
||
|
||
Arguments:
|
||
|
||
SmbDesiredAccess - The desired access specified in the received SMB.
|
||
(This includes desired access, share access, and other mode
|
||
bits.)
|
||
|
||
NtDesiredAccess - Returns the NT equivalent of the desired access
|
||
part of SmbDesiredAccess.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Indicates whether SmbDesiredAccess is valid.
|
||
|
||
--*/
|
||
|
||
{
|
||
PAGED_CODE( );
|
||
|
||
switch ( SmbDesiredAccess & SMB_DA_ACCESS_MASK ) {
|
||
|
||
case SMB_DA_ACCESS_READ:
|
||
|
||
*NtDesiredAccess = GENERIC_READ;
|
||
break;
|
||
|
||
case SMB_DA_ACCESS_WRITE:
|
||
|
||
//
|
||
// Having read attributes is implicit in having the file open in
|
||
// the SMB protocol, so request FILE_READ_ATTRIBUTES in addition
|
||
// to GENERIC_WRITE.
|
||
//
|
||
|
||
*NtDesiredAccess = GENERIC_WRITE | FILE_READ_ATTRIBUTES;
|
||
break;
|
||
|
||
case SMB_DA_ACCESS_READ_WRITE:
|
||
|
||
*NtDesiredAccess = GENERIC_READ | GENERIC_WRITE;
|
||
break;
|
||
|
||
case SMB_DA_ACCESS_EXECUTE:
|
||
|
||
// !!! is this right?
|
||
*NtDesiredAccess = GENERIC_READ | GENERIC_EXECUTE;
|
||
break;
|
||
|
||
default:
|
||
|
||
IF_DEBUG(SMB_ERRORS) {
|
||
KdPrint(( "MapDesiredAccess: Invalid desired access: 0x%lx\n",
|
||
SmbDesiredAccess ));
|
||
}
|
||
|
||
return STATUS_OS2_INVALID_ACCESS;
|
||
}
|
||
|
||
return STATUS_SUCCESS;
|
||
|
||
} // MapDesiredAccess
|
||
|
||
|
||
NTSTATUS SRVFASTCALL
|
||
MapOpenFunction(
|
||
IN USHORT SmbOpenFunction,
|
||
OUT PULONG NtCreateDisposition
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Maps an open function specification from SMB form to NT form.
|
||
|
||
Arguments:
|
||
|
||
WorkContext - Work context block for the operation.
|
||
|
||
SmbOpenFunction - The open function specified in the received SMB.
|
||
|
||
NtDesiredAccess - Returns the NT equivalent of SmbOpenFunction.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Indicates whether SmbOpenFunction is valid.
|
||
|
||
--*/
|
||
|
||
{
|
||
PAGED_CODE( );
|
||
|
||
// The OpenFunction bit mapping:
|
||
//
|
||
// rrrr rrrr rrrC rrOO
|
||
//
|
||
// where:
|
||
//
|
||
// C - Create (action to be taken if the file does not exist)
|
||
// 0 -- Fail
|
||
// 1 -- Create file
|
||
//
|
||
// O - Open (action to be taken if the file exists)
|
||
// 0 - Fail
|
||
// 1 - Open file
|
||
// 2 - Truncate file
|
||
//
|
||
|
||
switch ( SmbOpenFunction & (SMB_OFUN_OPEN_MASK | SMB_OFUN_CREATE_MASK) ) {
|
||
|
||
case SMB_OFUN_CREATE_FAIL | SMB_OFUN_OPEN_OPEN:
|
||
|
||
*NtCreateDisposition = FILE_OPEN;
|
||
break;
|
||
|
||
case SMB_OFUN_CREATE_CREATE | SMB_OFUN_OPEN_FAIL:
|
||
|
||
*NtCreateDisposition = FILE_CREATE;
|
||
break;
|
||
|
||
case SMB_OFUN_CREATE_CREATE | SMB_OFUN_OPEN_OPEN:
|
||
|
||
*NtCreateDisposition = FILE_OPEN_IF;
|
||
break;
|
||
|
||
case SMB_OFUN_CREATE_CREATE | SMB_OFUN_OPEN_TRUNCATE:
|
||
|
||
*NtCreateDisposition = FILE_OVERWRITE_IF;
|
||
break;
|
||
|
||
case SMB_OFUN_CREATE_FAIL | SMB_OFUN_OPEN_TRUNCATE:
|
||
|
||
*NtCreateDisposition = FILE_OVERWRITE;
|
||
break;
|
||
|
||
//case 0x00:
|
||
//case 0x03:
|
||
//case 0x13:
|
||
default:
|
||
|
||
IF_DEBUG(SMB_ERRORS) {
|
||
KdPrint(( "MapOpenFunction: Invalid open function: 0x%lx\n",
|
||
SmbOpenFunction ));
|
||
}
|
||
|
||
return STATUS_OS2_INVALID_ACCESS;
|
||
}
|
||
|
||
return STATUS_SUCCESS;
|
||
|
||
} // MapOpenFunction
|
||
|
||
|
||
NTSTATUS SRVFASTCALL
|
||
MapCacheHints(
|
||
IN USHORT SmbDesiredAccess,
|
||
IN OUT PULONG NtCreateFlags
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function maps the SMB cache mode hints to the NT format. The
|
||
NtCreateFlags are updated.
|
||
|
||
Arguments:
|
||
|
||
WorkContext - Work context block for the operation.
|
||
|
||
SmbOpenFunction - The open function specified in the received SMB.
|
||
|
||
NtCreateFlags - The NT file creation flags
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Indicates whether SmbOpenFunction is valid.
|
||
|
||
--*/
|
||
|
||
{
|
||
PAGED_CODE( );
|
||
|
||
// The DesiredAccess bit mapping:
|
||
//
|
||
// xxxC xLLL xxxx xxxx
|
||
//
|
||
// where:
|
||
//
|
||
// C - Cache mode
|
||
// 0 -- Normal file
|
||
// 1 -- Do not cache the file
|
||
//
|
||
// LLL - Locality of reference
|
||
// 000 - Unknown
|
||
// 001 - Mainly sequential access
|
||
// 010 - Mainly random access
|
||
// 011 - Random with some locality
|
||
// 1xx - Undefined
|
||
//
|
||
|
||
//
|
||
// If the client doesn't want us to use the cache, we can't give that, but we
|
||
// can at least get the data written immediately.
|
||
//
|
||
|
||
if ( SmbDesiredAccess & SMB_DO_NOT_CACHE ) {
|
||
*NtCreateFlags |= FILE_WRITE_THROUGH;
|
||
}
|
||
|
||
switch ( SmbDesiredAccess & SMB_LR_MASK ) {
|
||
|
||
case SMB_LR_UNKNOWN:
|
||
break;
|
||
|
||
case SMB_LR_SEQUENTIAL:
|
||
*NtCreateFlags |= FILE_SEQUENTIAL_ONLY;
|
||
break;
|
||
|
||
case SMB_LR_RANDOM:
|
||
case SMB_LR_RANDOM_WITH_LOCALITY:
|
||
*NtCreateFlags |= FILE_RANDOM_ACCESS;
|
||
break;
|
||
|
||
default:
|
||
|
||
IF_DEBUG(SMB_ERRORS) {
|
||
KdPrint(( "MapCacheHints: Invalid cache hint: 0x%lx\n",
|
||
SmbDesiredAccess ));
|
||
}
|
||
|
||
return STATUS_OS2_INVALID_ACCESS;
|
||
}
|
||
|
||
return STATUS_SUCCESS;
|
||
|
||
} // MapCacheHints
|
||
|
||
|
||
NTSTATUS SRVFASTCALL
|
||
MapShareAccess(
|
||
IN USHORT SmbDesiredAccess,
|
||
OUT PULONG NtShareAccess
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Maps a share access specification from SMB form to NT form.
|
||
|
||
Arguments:
|
||
|
||
SmbDesiredAccess - The desired access specified in the received SMB.
|
||
(This includes desired access, share access, and other mode
|
||
bits.)
|
||
|
||
NtShareAccess - Returns the NT equivalent of the share access part
|
||
of SmbDesiredAccess.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Indicates whether SmbDesiredAccess is valid.
|
||
|
||
--*/
|
||
|
||
{
|
||
PAGED_CODE( );
|
||
|
||
switch ( SmbDesiredAccess & SMB_DA_SHARE_MASK ) {
|
||
|
||
case SMB_DA_SHARE_EXCLUSIVE:
|
||
|
||
//
|
||
// Deny read and write.
|
||
//
|
||
|
||
*NtShareAccess = 0L;
|
||
break;
|
||
|
||
case SMB_DA_SHARE_DENY_WRITE:
|
||
|
||
//
|
||
// Deny write but allow read.
|
||
//
|
||
|
||
*NtShareAccess = FILE_SHARE_READ;
|
||
break;
|
||
|
||
case SMB_DA_SHARE_DENY_READ:
|
||
|
||
//
|
||
// Deny read but allow write.
|
||
//
|
||
|
||
*NtShareAccess = FILE_SHARE_WRITE;
|
||
break;
|
||
|
||
case SMB_DA_SHARE_DENY_NONE:
|
||
|
||
//
|
||
// Deny none -- allow other processes to read or write the file.
|
||
//
|
||
|
||
*NtShareAccess = FILE_SHARE_READ | FILE_SHARE_WRITE;
|
||
break;
|
||
|
||
default:
|
||
|
||
IF_DEBUG(SMB_ERRORS) {
|
||
KdPrint(( "MapShareAccess: Invalid share access: 0x%lx\n",
|
||
SmbDesiredAccess ));
|
||
}
|
||
|
||
return STATUS_OS2_INVALID_ACCESS;
|
||
}
|
||
|
||
return STATUS_SUCCESS;
|
||
|
||
} // MapShareAccess
|
||
|
||
|
||
NTSTATUS
|
||
SrvNtCreateFile(
|
||
IN OUT PWORK_CONTEXT WorkContext,
|
||
IN ULONG RootDirectoryFid,
|
||
IN ACCESS_MASK DesiredAccess,
|
||
IN LARGE_INTEGER AllocationSize,
|
||
IN ULONG FileAttributes,
|
||
IN ULONG ShareAccess,
|
||
IN ULONG CreateDisposition,
|
||
IN ULONG CreateOptions,
|
||
IN PVOID SecurityDescriptorBuffer OPTIONAL,
|
||
IN PUNICODE_STRING FileName,
|
||
IN PVOID EaBuffer OPTIONAL,
|
||
IN ULONG EaLength,
|
||
OUT PULONG EaErrorOffset OPTIONAL,
|
||
IN ULONG OptionFlags,
|
||
PSECURITY_QUALITY_OF_SERVICE QualityOfService,
|
||
IN OPLOCK_TYPE RequestedOplockType,
|
||
IN PRESTART_ROUTINE RestartRoutine
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Does most of the operations necessary to open or create a file.
|
||
First the UID and TID are verified and the corresponding session and
|
||
tree connect blocks located. The input file name name is
|
||
canonicalized, and a fully qualified name is formed. The file
|
||
is opened and the appropriate data structures are created.
|
||
|
||
Arguments:
|
||
|
||
WorkContext - Work context block for the operation.
|
||
|
||
RootDirectoryFid - The FID of an open root directory. The file is opened
|
||
relative to this directory.
|
||
|
||
DesiredAccess - The access type requested by the client.
|
||
|
||
AllocationSize - The initialize allocation size of the file. It is
|
||
only used if the file is created, overwritten, or superseded.
|
||
|
||
FileAttributes - Specified the file attributes.
|
||
|
||
ShareAccess - Specifies the type of share access requested by the
|
||
client.
|
||
|
||
CreateDisposition - Specifies the action to be taken if the file does
|
||
or does not exist.
|
||
|
||
CreateOptions - Specifies the options to use when creating the file.
|
||
|
||
SecurityDescriptorBuffer - The SD to set on the file.
|
||
|
||
FileName - The name of the file to open.
|
||
|
||
EaBuffer - The EAs to set on the file.
|
||
|
||
EaLength - Length, in bytes, of the EA buffer.
|
||
|
||
EaErrorOffset - Returns the offset, in bytes, in the EA buffer of
|
||
the EA error.
|
||
|
||
OptionFlags - The option flags for creating the file
|
||
|
||
QualityOfService - The security quality of service for the file
|
||
|
||
RestartRoutine - The restart routine for the caller.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Indicates what occurred.
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS status;
|
||
NTSTATUS completionStatus;
|
||
|
||
PMFCB mfcb;
|
||
PNONPAGED_MFCB nonpagedMfcb;
|
||
PRFCB rfcb;
|
||
|
||
PSESSION session;
|
||
PTREE_CONNECT treeConnect;
|
||
|
||
UNICODE_STRING relativeName;
|
||
UNICODE_STRING fullName;
|
||
BOOLEAN nameAllocated;
|
||
BOOLEAN relativeNameAllocated = FALSE;
|
||
SHARE_TYPE shareType;
|
||
PRFCB rootDirRfcb = NULL;
|
||
PLFCB rootDirLfcb;
|
||
BOOLEAN success;
|
||
ULONG attributes;
|
||
ULONG openRetries;
|
||
OBJECT_ATTRIBUTES objectAttributes;
|
||
HANDLE fileHandle;
|
||
IO_STATUS_BLOCK ioStatusBlock;
|
||
ULONG ioCreateFlags;
|
||
PSHARE fileShare = NULL;
|
||
BOOLEAN caseInsensitive;
|
||
ULONG hashValue;
|
||
|
||
PSRV_LOCK mfcbLock;
|
||
|
||
//
|
||
// NOTE ON MFCB REFERENCE COUNT HANDLING
|
||
//
|
||
// After finding or creating an MFCB for a file, we increment the
|
||
// MFCB reference count an extra time to simplify our
|
||
// synchronization logic. We hold MfcbListLock lock while
|
||
// finding/creating the MFCB, but release it after acquiring the the
|
||
// per-MFCB lock. After opening the file, we call CompleteOpen,
|
||
// which may need to queue an LFCB to the MFCB and thus need to
|
||
// increment the count. But it can't, because the MFCB list lock may
|
||
// not be acquired while the per-MFCB lock is held because of
|
||
// deadlock potential. The boolean LfcbAddedToMfcbList returned
|
||
// from CompleteOpen indicates whether it actually queued an LFCB to
|
||
// the MFCB. If it didn't, we need to release the extra reference.
|
||
//
|
||
// Note that it isn't often that we actually have to dereference the
|
||
// MFCB. This only occurs when the open fails.
|
||
//
|
||
|
||
BOOLEAN lfcbAddedToMfcbList;
|
||
|
||
PAGED_CODE( );
|
||
|
||
//
|
||
// Assume we won't need a temporary open.
|
||
//
|
||
|
||
WorkContext->Parameters2.Open.TemporaryOpen = FALSE;
|
||
|
||
//
|
||
// If a session block has not already been assigned to the current
|
||
// work context, verify the UID. If verified, the address of the
|
||
// session block corresponding to this user is stored in the
|
||
// WorkContext block and the session block is referenced.
|
||
//
|
||
// Find the tree connect corresponding to the given TID if a tree
|
||
// connect pointer has not already been put in the WorkContext block
|
||
// by an AndX command or a previous call to SrvCreateFile.
|
||
//
|
||
|
||
status = SrvVerifyUidAndTid(
|
||
WorkContext,
|
||
&session,
|
||
&treeConnect,
|
||
ShareTypeWild
|
||
);
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
IF_DEBUG(SMB_ERRORS) {
|
||
KdPrint(( "SrvNtCreateFile: Invalid UID or TID\n" ));
|
||
}
|
||
return status;
|
||
}
|
||
|
||
//
|
||
// If the session has expired, return that info
|
||
//
|
||
if( session->IsSessionExpired )
|
||
{
|
||
return SESSION_EXPIRED_STATUS_CODE;
|
||
}
|
||
|
||
if ( RootDirectoryFid != 0 ) {
|
||
|
||
rootDirRfcb = SrvVerifyFid(
|
||
WorkContext,
|
||
(USHORT)RootDirectoryFid,
|
||
FALSE,
|
||
NULL, // don't serialize with raw write
|
||
&status
|
||
);
|
||
|
||
if ( rootDirRfcb == SRV_INVALID_RFCB_POINTER ) {
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "SrvNtCreateFile: Invalid Root Dir FID: 0x%lx\n",
|
||
RootDirectoryFid ));
|
||
}
|
||
|
||
return status;
|
||
|
||
} else {
|
||
|
||
//
|
||
// Remove the redundant copy of the RFCB to prevent a redundant
|
||
// dereference of this RFCB.
|
||
//
|
||
|
||
WorkContext->Rfcb = NULL;
|
||
|
||
}
|
||
|
||
rootDirLfcb = rootDirRfcb->Lfcb;
|
||
|
||
}
|
||
|
||
//
|
||
// Here we begin share type specific processing.
|
||
//
|
||
|
||
shareType = treeConnect->Share->ShareType;
|
||
|
||
//
|
||
// If this operation may block, and we are running short of
|
||
// free work items, fail this SMB with an out of resources error.
|
||
// Note that a disk open will block if the file is currently oplocked.
|
||
//
|
||
|
||
if ( shareType == ShareTypeDisk && !WorkContext->BlockingOperation ) {
|
||
|
||
if ( SrvReceiveBufferShortage( ) ) {
|
||
|
||
if ( rootDirRfcb != NULL ) {
|
||
SrvDereferenceRfcb( rootDirRfcb );
|
||
}
|
||
|
||
SrvStatistics.BlockingSmbsRejected++;
|
||
|
||
return STATUS_INSUFF_SERVER_RESOURCES;
|
||
|
||
} else {
|
||
|
||
//
|
||
// SrvBlockingOpsInProgress has already been incremented.
|
||
// Flag this work item as a blocking operation.
|
||
//
|
||
|
||
WorkContext->BlockingOperation = TRUE;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
//
|
||
// Assume we won't need a temporary open.
|
||
//
|
||
|
||
switch ( shareType ) {
|
||
|
||
case ShareTypeDisk:
|
||
case ShareTypePipe:
|
||
|
||
//
|
||
// Canonicalize the path name so that it conforms to NT
|
||
// standards.
|
||
//
|
||
// *** Note that this operation allocates space for the name.
|
||
//
|
||
|
||
status = SrvCanonicalizePathName(
|
||
WorkContext,
|
||
treeConnect->Share,
|
||
RootDirectoryFid != 0 ? &rootDirLfcb->Mfcb->FileName : NULL,
|
||
FileName->Buffer,
|
||
((PCHAR)FileName->Buffer +
|
||
FileName->Length - sizeof(WCHAR)),
|
||
TRUE, // Strip trailing "."s
|
||
TRUE, // Name is always unicode
|
||
&relativeName
|
||
);
|
||
|
||
if ( !NT_SUCCESS( status ) ) {
|
||
|
||
//
|
||
// The path tried to do ..\ to get beyond the share it has
|
||
// accessed.
|
||
//
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "SrvNtCreateFile: Invalid pathname: "
|
||
"%wZ\n", FileName ));
|
||
}
|
||
|
||
if ( rootDirRfcb != NULL ) {
|
||
SrvDereferenceRfcb( rootDirRfcb );
|
||
}
|
||
return status;
|
||
|
||
}
|
||
|
||
//
|
||
// Form the fully qualified name of the file.
|
||
//
|
||
// *** Note that this operation allocates space for the name.
|
||
// This space is deallocated after the DoXxxOpen routine
|
||
// returns.
|
||
//
|
||
|
||
if ( shareType == ShareTypeDisk ) {
|
||
|
||
if ( RootDirectoryFid != 0 ) {
|
||
SrvAllocateAndBuildPathName(
|
||
&rootDirLfcb->Mfcb->FileName,
|
||
&relativeName,
|
||
NULL,
|
||
&fullName
|
||
);
|
||
} else {
|
||
SrvAllocateAndBuildPathName(
|
||
&treeConnect->Share->DosPathName,
|
||
&relativeName,
|
||
NULL,
|
||
&fullName
|
||
);
|
||
}
|
||
|
||
} else {
|
||
|
||
UNICODE_STRING pipePrefix;
|
||
|
||
if( !WorkContext->Session->IsNullSession &&
|
||
WorkContext->Session->IsLSNotified == FALSE ) {
|
||
|
||
//
|
||
// We have a pipe open request, not a NULL session, and
|
||
// we haven't gotten clearance from the license server yet.
|
||
// If this pipe requires clearance, get a license.
|
||
//
|
||
|
||
ULONG i;
|
||
BOOLEAN matchFound = FALSE;
|
||
|
||
ACQUIRE_LOCK_SHARED( &SrvConfigurationLock );
|
||
|
||
for ( i = 0; SrvPipesNeedLicense[i] != NULL ; i++ ) {
|
||
|
||
if ( _wcsicmp(
|
||
SrvPipesNeedLicense[i],
|
||
relativeName.Buffer
|
||
) == 0 ) {
|
||
matchFound = TRUE;
|
||
break;
|
||
}
|
||
}
|
||
|
||
RELEASE_LOCK( &SrvConfigurationLock );
|
||
|
||
if( matchFound == TRUE ) {
|
||
status = SrvXsLSOperation( WorkContext->Session,
|
||
XACTSRV_MESSAGE_LSREQUEST );
|
||
|
||
if( !NT_SUCCESS( status ) ) {
|
||
if( rootDirRfcb != NULL ) {
|
||
SrvDereferenceRfcb( rootDirRfcb );
|
||
}
|
||
return status;
|
||
}
|
||
}
|
||
}
|
||
|
||
RtlInitUnicodeString( &pipePrefix, StrSlashPipeSlash );
|
||
|
||
if( WorkContext->Endpoint->RemapPipeNames || treeConnect->RemapPipeNames ) {
|
||
|
||
//
|
||
// The RemapPipeNames flag is set, so remap the pipe name
|
||
// to "$$\<server>\<pipe name>".
|
||
//
|
||
// Note: this operation allocates space for pipeRelativeName.
|
||
//
|
||
|
||
status = RemapPipeName(
|
||
&WorkContext->Endpoint->TransportAddress,
|
||
treeConnect->RemapPipeNames ? &treeConnect->ServerName : NULL,
|
||
&relativeName,
|
||
&relativeNameAllocated
|
||
);
|
||
|
||
if( !NT_SUCCESS( status ) ) {
|
||
|
||
if( rootDirRfcb != NULL ) {
|
||
SrvDereferenceRfcb( rootDirRfcb );
|
||
}
|
||
|
||
return status;
|
||
}
|
||
}
|
||
SrvAllocateAndBuildPathName(
|
||
&pipePrefix,
|
||
&relativeName,
|
||
NULL,
|
||
&fullName
|
||
);
|
||
|
||
}
|
||
|
||
if ( fullName.Buffer == NULL ) {
|
||
|
||
//
|
||
// Unable to allocate heap for the full name.
|
||
//
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "SrvNtCreateFile: Unable to allocate heap for "
|
||
"full path name\n" ));
|
||
}
|
||
|
||
if ( rootDirRfcb != NULL ) {
|
||
SrvDereferenceRfcb( rootDirRfcb );
|
||
}
|
||
|
||
if( relativeNameAllocated ) {
|
||
FREE_HEAP( relativeName.Buffer );
|
||
}
|
||
|
||
return STATUS_INSUFF_SERVER_RESOURCES;
|
||
|
||
}
|
||
|
||
//
|
||
// Indicate that we must free the file name buffers on exit.
|
||
//
|
||
|
||
nameAllocated = TRUE;
|
||
|
||
break;
|
||
|
||
//
|
||
// Default case, illegal device type. This should never happen.
|
||
//
|
||
|
||
default:
|
||
|
||
// !!! Is this an appropriate error return code? Probably no.
|
||
return STATUS_INVALID_PARAMETER;
|
||
|
||
}
|
||
|
||
//
|
||
// Determine whether or not the path name is case sensitive.
|
||
//
|
||
|
||
if ( (WorkContext->RequestHeader->Flags & SMB_FLAGS_CASE_INSENSITIVE) ||
|
||
WorkContext->Session->UsingUppercasePaths )
|
||
{
|
||
|
||
attributes = OBJ_CASE_INSENSITIVE;
|
||
caseInsensitive = TRUE;
|
||
|
||
} else {
|
||
attributes = 0L;
|
||
caseInsensitive = FALSE;
|
||
}
|
||
|
||
if ( RootDirectoryFid != 0 ) {
|
||
|
||
SrvInitializeObjectAttributes_U(
|
||
&objectAttributes,
|
||
&relativeName,
|
||
attributes,
|
||
rootDirLfcb->FileHandle,
|
||
NULL
|
||
);
|
||
|
||
} else if ( WorkContext->TreeConnect->Share->ShareType == ShareTypePipe ) {
|
||
SrvInitializeObjectAttributes_U(
|
||
&objectAttributes,
|
||
&relativeName,
|
||
attributes,
|
||
SrvNamedPipeHandle,
|
||
NULL
|
||
);
|
||
} else {
|
||
|
||
fileShare = treeConnect->Share;
|
||
|
||
SrvInitializeObjectAttributes_U(
|
||
&objectAttributes,
|
||
&relativeName,
|
||
attributes,
|
||
NULL,
|
||
NULL
|
||
);
|
||
}
|
||
|
||
if ( SecurityDescriptorBuffer != NULL) {
|
||
objectAttributes.SecurityDescriptor = SecurityDescriptorBuffer;
|
||
}
|
||
|
||
//
|
||
// Always add read attributes since we need to query file info after
|
||
// the open.
|
||
//
|
||
|
||
DesiredAccess |= FILE_READ_ATTRIBUTES;
|
||
|
||
//
|
||
// Interpret the io create flags
|
||
//
|
||
|
||
ioCreateFlags = IO_CHECK_CREATE_PARAMETERS | IO_FORCE_ACCESS_CHECK;
|
||
|
||
if ( OptionFlags & NT_CREATE_OPEN_TARGET_DIR ) {
|
||
ioCreateFlags |= IO_OPEN_TARGET_DIRECTORY;
|
||
}
|
||
|
||
//
|
||
// Override the default server quality of service, with the QOS request
|
||
// by the client.
|
||
//
|
||
|
||
objectAttributes.SecurityQualityOfService = QualityOfService;
|
||
|
||
if ( WorkContext->ProcessingCount == 2 ) {
|
||
|
||
HANDLE fileHandle;
|
||
OBJECT_ATTRIBUTES objectAttributes;
|
||
IO_STATUS_BLOCK ioStatusBlock;
|
||
|
||
//
|
||
// This is the second time through, so we must be in a blocking
|
||
// thread. Do a blocking open of the file to force an oplock
|
||
// break. Then close the handle and fall through to the normal
|
||
// open path.
|
||
//
|
||
// We must do the blocking open without holding the MFCB
|
||
// lock, because this lock can be acquired during oplock
|
||
// break, resulting in deadlock.
|
||
//
|
||
|
||
SrvInitializeObjectAttributes_U(
|
||
&objectAttributes,
|
||
&relativeName,
|
||
attributes,
|
||
0,
|
||
NULL
|
||
);
|
||
|
||
status = SrvIoCreateFile(
|
||
WorkContext,
|
||
&fileHandle,
|
||
GENERIC_READ,
|
||
&objectAttributes,
|
||
&ioStatusBlock,
|
||
NULL,
|
||
0,
|
||
FILE_SHARE_VALID_FLAGS,
|
||
FILE_OPEN,
|
||
0,
|
||
NULL,
|
||
0,
|
||
CreateFileTypeNone,
|
||
NULL, // ExtraCreateParameters
|
||
0,
|
||
WorkContext->TreeConnect->Share
|
||
);
|
||
|
||
if ( NT_SUCCESS( status ) ) {
|
||
SRVDBG_CLAIM_HANDLE( fileHandle, "FIL", 13, 0 );
|
||
SRVDBG_RELEASE_HANDLE( fileHandle, "FIL", 18, 0 );
|
||
SrvNtClose( fileHandle, TRUE );
|
||
}
|
||
}
|
||
|
||
//
|
||
// Scan the Master File Table to see if the named file is already
|
||
// open.
|
||
//
|
||
|
||
mfcb = SrvFindMfcb( &fullName, caseInsensitive, &mfcbLock, &hashValue, WorkContext );
|
||
|
||
if ( mfcb == NULL ) {
|
||
//
|
||
// There is no MFCB for this file. Create one.
|
||
//
|
||
|
||
mfcb = SrvCreateMfcb( &fullName, WorkContext, hashValue );
|
||
|
||
if ( mfcb == NULL ) {
|
||
|
||
//
|
||
// Failure to add open file instance to MFT.
|
||
//
|
||
|
||
if( mfcbLock ) {
|
||
RELEASE_LOCK( mfcbLock );
|
||
}
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "SrvNtCreateFile: Unable to allocate MFCB\n" ));
|
||
}
|
||
|
||
if ( nameAllocated ) {
|
||
FREE_HEAP( fullName.Buffer );
|
||
}
|
||
|
||
if( relativeNameAllocated ) {
|
||
FREE_HEAP( relativeName.Buffer );
|
||
}
|
||
|
||
if ( rootDirRfcb != NULL ) {
|
||
SrvDereferenceRfcb( rootDirRfcb );
|
||
}
|
||
|
||
return STATUS_INSUFF_SERVER_RESOURCES;
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
// Increment the MFCB reference count. See the note at the beginning of this routine.
|
||
//
|
||
mfcb->BlockHeader.ReferenceCount++;
|
||
UPDATE_REFERENCE_HISTORY( mfcb, FALSE );
|
||
|
||
//
|
||
// Grab the MFCB-based lock to serialize opens of the same file
|
||
// and release the MFCB list lock.
|
||
//
|
||
|
||
nonpagedMfcb = mfcb->NonpagedMfcb;
|
||
RELEASE_LOCK( mfcbLock );
|
||
ACQUIRE_LOCK( &nonpagedMfcb->Lock );
|
||
|
||
openRetries = SrvSharingViolationRetryCount;
|
||
|
||
start_retry:
|
||
|
||
//
|
||
// If the client asked for FILE_NO_INTERMEDIATE_BUFFERING, turn that
|
||
// flag off and turn FILE_WRITE_THROUGH on instead. We cannot give
|
||
// the client the true meaning of NO_INTERMEDIATE_BUFFERING, but we
|
||
// can at least get the data out to disk right away.
|
||
//
|
||
|
||
if ( (CreateOptions & FILE_NO_INTERMEDIATE_BUFFERING) != 0 ) {
|
||
CreateOptions |= FILE_WRITE_THROUGH;
|
||
CreateOptions &= ~FILE_NO_INTERMEDIATE_BUFFERING;
|
||
}
|
||
|
||
//
|
||
// Check to see if there is a cached handle for the file.
|
||
//
|
||
|
||
if ( (CreateDisposition == FILE_OPEN) ||
|
||
(CreateDisposition == FILE_CREATE) ||
|
||
(CreateDisposition == FILE_OPEN_IF) ) {
|
||
|
||
IF_DEBUG(FILE_CACHE) {
|
||
KdPrint(( "SrvNtCreateFile: checking for cached rfcb for %wZ\n", &fullName ));
|
||
}
|
||
if ( SrvFindCachedRfcb(
|
||
WorkContext,
|
||
mfcb,
|
||
DesiredAccess,
|
||
ShareAccess,
|
||
CreateDisposition,
|
||
CreateOptions,
|
||
RequestedOplockType,
|
||
&status ) ) {
|
||
|
||
IF_DEBUG(FILE_CACHE) {
|
||
KdPrint(( "SrvNtCreateFile: FindCachedRfcb = TRUE, status = %x, rfcb = %p\n",
|
||
status, WorkContext->Rfcb ));
|
||
}
|
||
|
||
RELEASE_LOCK( &nonpagedMfcb->Lock );
|
||
|
||
//
|
||
// We incremented the MFCB reference count in anticipation of
|
||
// the possibility that an LFCB might be queued to the MFCB.
|
||
// This path precludes that possibility.
|
||
//
|
||
|
||
SrvDereferenceMfcb( mfcb );
|
||
|
||
//
|
||
// This second dereference is for the reference done by
|
||
// SrvFindMfcb/SrvCreateMfcb.
|
||
//
|
||
|
||
SrvDereferenceMfcb( mfcb );
|
||
|
||
if ( nameAllocated ) {
|
||
FREE_HEAP( fullName.Buffer );
|
||
}
|
||
|
||
if( relativeNameAllocated ) {
|
||
FREE_HEAP( relativeName.Buffer );
|
||
}
|
||
|
||
if ( rootDirRfcb != NULL ) {
|
||
SrvDereferenceRfcb( rootDirRfcb );
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
IF_DEBUG(FILE_CACHE) {
|
||
KdPrint(( "SrvNtCreateFile: FindCachedRfcb = FALSE; do it the slow way\n" ));
|
||
}
|
||
}
|
||
|
||
//
|
||
// Call SrvIoCreateFile to create or open the file. (We call
|
||
// SrvIoCreateFile, rather than NtOpenFile, in order to get user-mode
|
||
// access checking.)
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "SrvCreateFile: Opening file %wZ\n", &fullName ));
|
||
}
|
||
|
||
CreateOptions |= FILE_COMPLETE_IF_OPLOCKED;
|
||
|
||
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpenAttempts );
|
||
|
||
//
|
||
// Ensure the EaBuffer is correctly formatted. Since we are a kernel mode
|
||
// component, the Io subsystem does not check it for us.
|
||
//
|
||
if( ARGUMENT_PRESENT( EaBuffer ) ) {
|
||
status = IoCheckEaBufferValidity( (PFILE_FULL_EA_INFORMATION)EaBuffer, EaLength, EaErrorOffset );
|
||
} else {
|
||
status = STATUS_SUCCESS;
|
||
}
|
||
|
||
if( NT_SUCCESS( status ) ) {
|
||
|
||
status = SrvIoCreateFile(
|
||
WorkContext,
|
||
&fileHandle,
|
||
DesiredAccess,
|
||
&objectAttributes,
|
||
&ioStatusBlock,
|
||
&AllocationSize,
|
||
FileAttributes,
|
||
ShareAccess,
|
||
CreateDisposition,
|
||
CreateOptions,
|
||
EaBuffer,
|
||
EaLength,
|
||
CreateFileTypeNone,
|
||
NULL, // ExtraCreateParameters
|
||
ioCreateFlags,
|
||
fileShare
|
||
);
|
||
}
|
||
|
||
//
|
||
// If we got sharing violation and this is a disk file.
|
||
// If this is the first open attempt, setup for a blocking open attempt.
|
||
// If the file is batch oplocked, the non-blocking open would fail,
|
||
// and the oplock will not break.
|
||
//
|
||
// If this is the second open attempt, we can assume that we are in
|
||
// the blocking thread. Retry the open.
|
||
//
|
||
|
||
if ( status == STATUS_SHARING_VIOLATION &&
|
||
WorkContext->TreeConnect->Share->ShareType == ShareTypeDisk ) {
|
||
|
||
if ( WorkContext->ProcessingCount == 1 ) {
|
||
|
||
WorkContext->Parameters2.Open.TemporaryOpen = TRUE;
|
||
|
||
} else if ( (WorkContext->ProcessingCount == 2) &&
|
||
(openRetries-- > 0) ) {
|
||
|
||
//
|
||
// We are in the blocking thread.
|
||
//
|
||
|
||
//
|
||
// Release the mfcb lock so that a close might slip through.
|
||
//
|
||
|
||
RELEASE_LOCK( &nonpagedMfcb->Lock );
|
||
|
||
(VOID) KeDelayExecutionThread(
|
||
KernelMode,
|
||
FALSE,
|
||
&SrvSharingViolationDelay
|
||
);
|
||
|
||
ACQUIRE_LOCK( &nonpagedMfcb->Lock );
|
||
goto start_retry;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Save the open information where the SMB processor can find it.
|
||
//
|
||
|
||
WorkContext->Irp->IoStatus.Information = ioStatusBlock.Information;
|
||
|
||
//
|
||
// If the user didn't have this permission, update the statistics
|
||
// database.
|
||
//
|
||
|
||
if ( status == STATUS_ACCESS_DENIED ) {
|
||
SrvStatistics.AccessPermissionErrors++;
|
||
}
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
|
||
//
|
||
// The open failed.
|
||
//
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
KdPrint(( "SrvNtCreateFile: SrvIoCreateFile failed, file = %wZ, "
|
||
"status = %X, Info = 0x%p\n",
|
||
objectAttributes.ObjectName,
|
||
status, (PVOID)ioStatusBlock.Information ));
|
||
}
|
||
|
||
//
|
||
// Set the error offset if needed.
|
||
//
|
||
|
||
if ( ARGUMENT_PRESENT(EaErrorOffset) &&
|
||
status == STATUS_INVALID_EA_NAME ) {
|
||
*EaErrorOffset = (ULONG)ioStatusBlock.Information;
|
||
ioStatusBlock.Information = 0;
|
||
}
|
||
|
||
//
|
||
// Cleanup allocated memory and return with a failure status.
|
||
//
|
||
|
||
RELEASE_LOCK( &nonpagedMfcb->Lock );
|
||
|
||
//
|
||
// We incremented the MFCB reference count in anticipation of
|
||
// the possibility that an LFCB might be queued to the MFCB.
|
||
// This error path precludes that possibility.
|
||
//
|
||
|
||
SrvDereferenceMfcb( mfcb );
|
||
|
||
//
|
||
// This second dereference is for the reference done by
|
||
// SrvFindMfcb/SrvCreateMfcb.
|
||
//
|
||
|
||
SrvDereferenceMfcb( mfcb );
|
||
|
||
if ( nameAllocated ) {
|
||
FREE_HEAP( fullName.Buffer );
|
||
}
|
||
|
||
if( relativeNameAllocated ) {
|
||
FREE_HEAP( relativeName.Buffer );
|
||
}
|
||
|
||
if ( rootDirRfcb != NULL ) {
|
||
SrvDereferenceRfcb( rootDirRfcb );
|
||
}
|
||
return status;
|
||
|
||
}
|
||
|
||
SRVDBG_CLAIM_HANDLE( fileHandle, "FIL", 14, 0 );
|
||
|
||
//
|
||
// The open was successful. Attempt to allocate structures to
|
||
// represent the open. If any errors occur, CompleteOpen does full
|
||
// cleanup, including closing the file.
|
||
//
|
||
|
||
IF_SMB_DEBUG(OPEN_CLOSE2) {
|
||
KdPrint(( "SrvNtCreateFile: Open of %wZ succeeded, file handle: 0x%p\n", &fullName, fileHandle ));
|
||
}
|
||
|
||
completionStatus = CompleteOpen(
|
||
&rfcb,
|
||
mfcb,
|
||
WorkContext,
|
||
NULL,
|
||
fileHandle,
|
||
NULL,
|
||
ShareAccess,
|
||
CreateOptions,
|
||
FALSE,
|
||
FALSE,
|
||
&lfcbAddedToMfcbList
|
||
);
|
||
|
||
//
|
||
// Remember the "interesting" status code. If CompleteOpen() succeeds
|
||
// return the open status. If it fails, it will clean up the open
|
||
// file, and we return a failure status.
|
||
//
|
||
|
||
if ( !NT_SUCCESS( completionStatus ) ) {
|
||
status = completionStatus;
|
||
}
|
||
|
||
//
|
||
// Release the Open serialization lock and dereference the MFCB.
|
||
//
|
||
|
||
RELEASE_LOCK( &nonpagedMfcb->Lock );
|
||
|
||
//
|
||
// If CompleteOpen didn't queue an LFCB to the MFCB, release the
|
||
// extra reference that we added.
|
||
//
|
||
|
||
if ( !lfcbAddedToMfcbList ) {
|
||
SrvDereferenceMfcb( mfcb );
|
||
}
|
||
|
||
SrvDereferenceMfcb( mfcb );
|
||
|
||
//
|
||
// Deallocate the full path name buffer.
|
||
//
|
||
|
||
if ( nameAllocated ) {
|
||
FREE_HEAP( fullName.Buffer );
|
||
}
|
||
|
||
//
|
||
// Deallocate the relative path name buffer.
|
||
//
|
||
if( relativeNameAllocated ) {
|
||
FREE_HEAP( relativeName.Buffer );
|
||
}
|
||
|
||
//
|
||
// Release our reference to the root directory RFCB
|
||
//
|
||
|
||
if ( rootDirRfcb != NULL ) {
|
||
SrvDereferenceRfcb( rootDirRfcb );
|
||
}
|
||
|
||
//
|
||
// If this is a temporary file, don't attempt to cache it.
|
||
//
|
||
|
||
if ( rfcb != NULL && (FileAttributes & FILE_ATTRIBUTE_TEMPORARY) != 0 ) {
|
||
|
||
rfcb->IsCacheable = FALSE;
|
||
}
|
||
|
||
//
|
||
// Update the statistics database if the open was successful.
|
||
//
|
||
|
||
if ( NT_SUCCESS(status) ) {
|
||
SrvStatistics.TotalFilesOpened++;
|
||
}
|
||
|
||
//
|
||
// Make a pointer to the RFCB accessible to the caller.
|
||
//
|
||
|
||
WorkContext->Parameters2.Open.Rfcb = rfcb;
|
||
|
||
//
|
||
// If there is an oplock break in progress, wait for the oplock
|
||
// break to complete.
|
||
//
|
||
|
||
if ( status == STATUS_OPLOCK_BREAK_IN_PROGRESS ) {
|
||
|
||
NTSTATUS startStatus;
|
||
|
||
//
|
||
// Save the Information from the open, so it doesn't
|
||
// get lost when we re-use the WorkContext->Irp for the
|
||
// oplock processing.
|
||
//
|
||
WorkContext->Parameters2.Open.IosbInformation = WorkContext->Irp->IoStatus.Information;
|
||
|
||
startStatus = SrvStartWaitForOplockBreak(
|
||
WorkContext,
|
||
RestartRoutine,
|
||
0,
|
||
rfcb->Lfcb->FileObject
|
||
);
|
||
|
||
if (!NT_SUCCESS( startStatus ) ) {
|
||
|
||
//
|
||
// The file is oplocked, and we cannot wait for the oplock
|
||
// break to complete. Just close the file, and return the
|
||
// error.
|
||
//
|
||
|
||
SrvCloseRfcb( rfcb );
|
||
status = startStatus;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
return status;
|
||
|
||
} // SrvNtCreateFile
|
||
|
||
BOOLEAN
|
||
SetDefaultPipeMode (
|
||
IN HANDLE FileHandle
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function set the read mode of a newly opened named pipe. If
|
||
the pipe type is message mode, the read mode is set the message
|
||
mode.
|
||
|
||
Arguments:
|
||
|
||
FileHandle - The client side handle to the named pipe.
|
||
|
||
Return Value:
|
||
|
||
FALSE - Pipe mode is byte mode.
|
||
TRUE - Pipe mode has been set to message mode.
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS status;
|
||
IO_STATUS_BLOCK ioStatusBlock;
|
||
FILE_PIPE_INFORMATION pipeInformation;
|
||
FILE_PIPE_LOCAL_INFORMATION pipeLocalInformation;
|
||
|
||
PAGED_CODE( );
|
||
|
||
status = NtQueryInformationFile(
|
||
FileHandle,
|
||
&ioStatusBlock,
|
||
(PVOID)&pipeLocalInformation,
|
||
sizeof(pipeLocalInformation),
|
||
FilePipeLocalInformation
|
||
);
|
||
|
||
if ( !NT_SUCCESS( status )) {
|
||
return FALSE;
|
||
}
|
||
|
||
if ( pipeLocalInformation.NamedPipeType != FILE_PIPE_MESSAGE_TYPE ) {
|
||
return FALSE;
|
||
}
|
||
|
||
pipeInformation.ReadMode = FILE_PIPE_MESSAGE_MODE;
|
||
pipeInformation.CompletionMode = FILE_PIPE_QUEUE_OPERATION;
|
||
|
||
//
|
||
// ???: is it ok to ignore the return status for this call?
|
||
//
|
||
|
||
NtSetInformationFile(
|
||
FileHandle,
|
||
&ioStatusBlock,
|
||
(PVOID)&pipeInformation,
|
||
sizeof(pipeInformation),
|
||
FilePipeInformation
|
||
);
|
||
|
||
return TRUE;
|
||
|
||
} // SetDefaultPipeMode
|
||
|
||
BOOLEAN
|
||
SrvFailMdlReadDev (
|
||
IN PFILE_OBJECT FileObject,
|
||
IN PLARGE_INTEGER FileOffset,
|
||
IN ULONG Length,
|
||
IN ULONG LockKey,
|
||
OUT PMDL *MdlChain,
|
||
OUT PIO_STATUS_BLOCK IoStatus,
|
||
IN PDEVICE_OBJECT DeviceObject
|
||
)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
BOOLEAN
|
||
SrvFailPrepareMdlWriteDev (
|
||
IN PFILE_OBJECT FileObject,
|
||
IN PLARGE_INTEGER FileOffset,
|
||
IN ULONG Length,
|
||
IN ULONG LockKey,
|
||
OUT PMDL *MdlChain,
|
||
OUT PIO_STATUS_BLOCK IoStatus,
|
||
IN PDEVICE_OBJECT DeviceObject
|
||
)
|
||
{
|
||
return FALSE;
|
||
}
|