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

735 lines
19 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
Create.c
Abstract:
This module implements the File Create routine for NPFS called by the
dispatch driver.
Author:
Gary Kimura [GaryKi] 21-Aug-1990
Revision History:
--*/
#include "NpProcs.h"
//
// The debug trace level
//
#define Dbg (DEBUG_TRACE_CREATE)
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, NpCommonCreate)
#pragma alloc_text(PAGE, NpFsdCreate)
#pragma alloc_text(PAGE, NpOpenNamedPipeFileSystem)
#pragma alloc_text(PAGE, NpOpenNamedPipeRootDirectory)
#pragma alloc_text(PAGE, NpCreateClientEnd)
#endif
NTSTATUS
NpFsdCreate (
IN PNPFS_DEVICE_OBJECT NpfsDeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine implements the FSD part of the NtCreateFile and NtOpenFile
API calls.
Arguments:
NpfsDeviceObject - Supplies the device object to use.
Irp - Supplies the Irp being processed
Return Value:
NTSTATUS - The Fsd status for the Irp
--*/
{
NTSTATUS Status;
PAGED_CODE();
DebugTrace(+1, Dbg, "NpFsdCreate\n", 0);
//
// Call the common create routine.
//
FsRtlEnterFileSystem();
Status = NpCommonCreate( NpfsDeviceObject, Irp );
FsRtlExitFileSystem();
//
// And return to our caller
//
DebugTrace(-1, Dbg, "NpFsdCreate -> %08lx\n", Status );
return Status;
}
//
// Internal support routine
//
NTSTATUS
NpCommonCreate (
IN PNPFS_DEVICE_OBJECT NpfsDeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for creating/opening a file.
Arguments:
NpfsDeviceObject - Device object for npfs
Irp - Supplies the Irp to process
DeferredList - List of IRP's to complete later
Return Value:
NTSTATUS - the return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
PFILE_OBJECT FileObject;
PFILE_OBJECT RelatedFileObject;
UNICODE_STRING FileName;
ACCESS_MASK DesiredAccess;
USHORT ShareAccess;
BOOLEAN CaseInsensitive = TRUE; //**** Make all searches case insensitive
PFCB Fcb;
UNICODE_STRING RemainingPart;
LIST_ENTRY DeferredList;
PAGED_CODE();
InitializeListHead (&DeferredList);
//
// Reference our input parameters to make things easier
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
FileObject = IrpSp->FileObject;
RelatedFileObject = IrpSp->FileObject->RelatedFileObject;
FileName = *(PUNICODE_STRING)&IrpSp->FileObject->FileName;
DesiredAccess = IrpSp->Parameters.Create.SecurityContext->DesiredAccess;
ShareAccess = IrpSp->Parameters.Create.ShareAccess;
DebugTrace(+1, Dbg, "NpCommonCreate\n", 0 );
DebugTrace( 0, Dbg, "NpfsDeviceObject = %08xl\n", NpfsDeviceObject );
DebugTrace( 0, Dbg, "Irp = %08xl\n", Irp );
DebugTrace( 0, Dbg, "FileObject = %08xl\n", FileObject );
DebugTrace( 0, Dbg, "RelatedFileObject = %08xl\n", RelatedFileObject );
DebugTrace( 0, Dbg, "FileName = %Z\n", &FileName );
DebugTrace( 0, Dbg, "DesiredAccess = %08xl\n", DesiredAccess );
DebugTrace( 0, Dbg, "ShareAccess = %08xl\n", ShareAccess );
//
// Acquire exclusive access to the Vcb
//
NpAcquireExclusiveVcb();
try {
//
// Check if we are trying to open the named pipe file system
// (i.e., the Vcb).
//
if ((FileName.Length == 0) &&
((RelatedFileObject == NULL) || (NodeType(RelatedFileObject->FsContext) == NPFS_NTC_VCB))) {
DebugTrace(0, Dbg, "Open name pipe file system\n", 0);
Irp->IoStatus = NpOpenNamedPipeFileSystem( FileObject,
DesiredAccess,
ShareAccess );
Status = Irp->IoStatus.Status;
try_return( NOTHING );
}
//
// Check if we are trying to open the root directory
//
if (((FileName.Length == 2) && (FileName.Buffer[0] == L'\\') && (RelatedFileObject == NULL))
||
((FileName.Length == 0) && (NodeType(RelatedFileObject->FsContext) == NPFS_NTC_ROOT_DCB))) {
DebugTrace(0, Dbg, "Open root directory system\n", 0);
Irp->IoStatus = NpOpenNamedPipeRootDirectory( NpVcb->RootDcb,
FileObject,
DesiredAccess,
ShareAccess,
&DeferredList );
Status = Irp->IoStatus.Status;
try_return( NOTHING );
}
//
// If the name is an alias, translate it.
//
Status = NpTranslateAlias( &FileName );
if ( !NT_SUCCESS(Status) ) {
try_return( NOTHING );
}
//
// If there is a related file object then this is a relative open
// and it better be the root dcb. Both the then and the else clause
// return an Fcb.
//
if (RelatedFileObject != NULL) {
PDCB Dcb;
Dcb = RelatedFileObject->FsContext;
if (NodeType(Dcb) != NPFS_NTC_ROOT_DCB) {
DebugTrace(0, Dbg, "Bad file name\n", 0);
try_return( Status = STATUS_OBJECT_NAME_INVALID );
}
Status = NpFindRelativePrefix( Dcb, &FileName, CaseInsensitive, &RemainingPart, &Fcb );
if (!NT_SUCCESS (Status)) {
try_return( NOTHING );
}
} else {
//
// The only nonrelative name we allow are of the form "\pipe-name"
//
if ((FileName.Length <= 2) || (FileName.Buffer[0] != L'\\')) {
DebugTrace(0, Dbg, "Bad file name\n", 0);
try_return( Status = STATUS_OBJECT_NAME_INVALID );
}
Fcb = NpFindPrefix( &FileName, CaseInsensitive, &RemainingPart );
}
//
// If the remaining name is not empty then we have an error, either
// we have an illegal name or a non-existent name.
//
if (RemainingPart.Length != 0) {
if (Fcb->NodeTypeCode == NPFS_NTC_FCB) {
//
// We were given a name such as "\pipe-name\another-name"
//
DebugTrace(0, Dbg, "Illegal object name\n", 0);
Status = STATUS_OBJECT_NAME_INVALID;
} else {
//
// We were given a non-existent name
//
DebugTrace(0, Dbg, "non-existent name\n", 0);
Status = STATUS_OBJECT_NAME_NOT_FOUND;
}
} else {
//
// The remaining name is empty so we better have an Fcb otherwise
// we have an invalid object name.
//
if (Fcb->NodeTypeCode == NPFS_NTC_FCB) {
DebugTrace(0, Dbg, "Create client end named pipe, Fcb = %08lx\n", Fcb );
//
// If the server has no handles open, then pretend that
// the pipe name doesn't exist.
//
if ( Fcb->ServerOpenCount == 0 ) {
Status = STATUS_OBJECT_NAME_NOT_FOUND;
} else {
Irp->IoStatus = NpCreateClientEnd( Fcb,
FileObject,
DesiredAccess,
ShareAccess,
IrpSp->Parameters.Create.SecurityContext->SecurityQos,
IrpSp->Parameters.Create.SecurityContext->AccessState,
(KPROCESSOR_MODE)(FlagOn(IrpSp->Flags, SL_FORCE_ACCESS_CHECK) ?
UserMode : Irp->RequestorMode),
Irp->Tail.Overlay.Thread,
&DeferredList );
Status = Irp->IoStatus.Status;
}
} else {
DebugTrace(0, Dbg, "Illegal object name\n", 0);
Status = STATUS_OBJECT_NAME_INVALID;
}
}
try_exit: NOTHING;
} finally {
NpReleaseVcb ();
//
// Complete any deferred IRPs
//
NpCompleteDeferredIrps (&DeferredList);
NpCompleteRequest (Irp, Status);
DebugTrace(-1, Dbg, "NpCommonCreate -> %08lx\n", Status);
}
return Status;
}
//
// Internal support routine
//
IO_STATUS_BLOCK
NpCreateClientEnd (
IN PFCB Fcb,
IN PFILE_OBJECT FileObject,
IN ACCESS_MASK DesiredAccess,
IN USHORT ShareAccess,
IN PSECURITY_QUALITY_OF_SERVICE SecurityQos,
IN PACCESS_STATE AccessState,
IN KPROCESSOR_MODE RequestorMode,
IN PETHREAD UserThread,
IN PLIST_ENTRY DeferredList
)
/*++
Routine Description:
This routine performs the operation for opening the client end of a named
pipe. This routine does not complete the IRP, it performs the function
and then returns a status
Arguments:
Fcb - Supplies the Fcb for the named pipe being accessed
FileObject - Supplies the file object associated with the client end
DesiredAccess - Supplies the callers desired access
ShareAccess - Supplies the callers share access
SecurityQos - Supplies the security qos parameter from the create irp
AccessState - Supplies the access state parameter from the create irp
RequestorMode - Supplies the mode of the originating irp
UserTherad - Supplies the client end user thread
DeferredList - List of IRP's to complete later
Return Value:
IO_STATUS_BLOCK - Returns the appropriate status for the operation
--*/
{
IO_STATUS_BLOCK Iosb={0};
NAMED_PIPE_CONFIGURATION NamedPipeConfiguration;
BOOLEAN AccessGranted;
ACCESS_MASK GrantedAccess;
UNICODE_STRING Name;
PCCB Ccb;
PNONPAGED_CCB NonpagedCcb;
PLIST_ENTRY Links;
PPRIVILEGE_SET Privileges = NULL;
DebugTrace(+1, Dbg, "NpCreateClientEnd\n", 0 );
NamedPipeConfiguration = Fcb->Specific.Fcb.NamedPipeConfiguration;
//
// "Create Pipe Instance" access is part of generic write and so
// we need to mask out the bit. Even if the client has explicitly
// asked for "create pipe instance" access we will mask it out.
// This will allow the default ACL to be strengthened to protect
// against spurious threads from creating new pipe instances.
//
DesiredAccess &= ~FILE_CREATE_PIPE_INSTANCE;
//
// First do an access check for the user against the Fcb
//
SeLockSubjectContext( &AccessState->SubjectSecurityContext );
AccessGranted = SeAccessCheck( Fcb->SecurityDescriptor,
&AccessState->SubjectSecurityContext,
TRUE, // Tokens are locked
DesiredAccess,
0,
&Privileges,
IoGetFileObjectGenericMapping(),
RequestorMode,
&GrantedAccess,
&Iosb.Status
);
if (Privileges != NULL) {
(VOID) SeAppendPrivileges(
AccessState,
Privileges
);
SeFreePrivileges( Privileges );
}
//
// Transfer over the access masks from what is desired to
// what we just granted. Also patch up the maximum allowed
// case because we just did the mapping for it. Note that if
// the user didn't ask for maximum allowed then the following
// code is still okay because we'll just zero a zero bit.
//
if (AccessGranted) {
AccessState->PreviouslyGrantedAccess |= GrantedAccess;
AccessState->RemainingDesiredAccess &= ~(GrantedAccess | MAXIMUM_ALLOWED);
}
RtlInitUnicodeString( &Name, L"NamedPipe" );
SeOpenObjectAuditAlarm( &Name,
NULL,
&FileObject->FileName,
Fcb->SecurityDescriptor,
AccessState,
FALSE,
AccessGranted,
RequestorMode,
&AccessState->GenerateOnClose );
SeUnlockSubjectContext( &AccessState->SubjectSecurityContext );
if (!AccessGranted) {
DebugTrace(0, Dbg, "Access Denied\n", 0 );
return Iosb;
}
//
// Check if the user wants to write to an outbound pipe or read from
// and inbound pipe. And if so then tell the user the error
//
if ((FlagOn(DesiredAccess, FILE_READ_DATA) && (NamedPipeConfiguration == FILE_PIPE_INBOUND)) ||
(FlagOn(DesiredAccess, FILE_WRITE_DATA) && (NamedPipeConfiguration == FILE_PIPE_OUTBOUND))) {
Iosb.Status = STATUS_ACCESS_DENIED;
return Iosb;
}
//
// First try and find a ccb that is in the listening state. If we
// exit the loop with Ccb not equal to null then we've found one.
//
Ccb = NULL;
for (Links = Fcb->Specific.Fcb.CcbQueue.Flink;
Links != &Fcb->Specific.Fcb.CcbQueue;
Links = Links->Flink) {
Ccb = CONTAINING_RECORD( Links, CCB, CcbLinks );
NonpagedCcb = Ccb->NonpagedCcb;
if (Ccb->NamedPipeState == FILE_PIPE_LISTENING_STATE) {
DebugTrace(0, Dbg, "Located listening ccb = %08lx\n", Ccb);
break;
}
Ccb = NULL;
}
//
// Check that we found one
//
if (Ccb == NULL) {
Iosb.Status = STATUS_PIPE_NOT_AVAILABLE;
return Iosb;
}
NpfsVerifyCcb( __FILE__, __LINE__, Ccb );
//
// Now make sure our share access is okay. If the user is asking
// for read data then given him shared read, if he's asking for
// write data then given him shared write.
//
if (NamedPipeConfiguration == FILE_PIPE_OUTBOUND) {
ShareAccess = FILE_SHARE_READ;
} else if (NamedPipeConfiguration == FILE_PIPE_INBOUND) {
ShareAccess = FILE_SHARE_WRITE;
} else {
ShareAccess = (FILE_SHARE_READ | FILE_SHARE_WRITE);
}
if (FlagOn(DesiredAccess, FILE_READ_DATA )) { ShareAccess |= FILE_SHARE_READ; }
if (FlagOn(DesiredAccess, FILE_WRITE_DATA)) { ShareAccess |= FILE_SHARE_WRITE; }
if (!NT_SUCCESS(Iosb.Status = NpInitializeSecurity( Ccb,
SecurityQos,
UserThread ))) {
DebugTrace(0, Dbg, "Security QOS error\n", 0);
return Iosb;
}
//
// Set the pipe into the connect state, the read mode to byte stream,
// and the completion mode to queued operation. This also
// sets the client file object's back pointer to the ccb
//
if (!NT_SUCCESS(Iosb.Status = NpSetConnectedPipeState( Ccb,
FileObject,
DeferredList ))) {
NpUninitializeSecurity (Ccb);
NpfsVerifyCcb( __FILE__, __LINE__, Ccb );
return Iosb;
}
NpfsVerifyCcb( __FILE__, __LINE__, Ccb );
//
// Set up the client session and info. NULL for the
// client info indicates a local session.
//
Ccb->ClientInfo = NULL;
Ccb->ClientProcess = IoThreadToProcess( UserThread );
NpfsVerifyCcb( __FILE__, __LINE__, Ccb );
//
// And set our return status
//
Iosb.Status = STATUS_SUCCESS;
Iosb.Information = FILE_OPENED;
DebugTrace(-1, Dbg, "NpCreateClientEnd -> %08lx\n", Iosb.Status);
return Iosb;
}
//
// Internal support routine
//
IO_STATUS_BLOCK
NpOpenNamedPipeFileSystem (
IN PFILE_OBJECT FileObject,
IN ACCESS_MASK DesiredAccess,
IN USHORT ShareAccess
)
{
IO_STATUS_BLOCK Iosb = {0};
PAGED_CODE();
DebugTrace(+1, Dbg, "NpOpenNamedPipeFileSystem, Vcb = %08lx\n", NpVcb);
//
// Set the new share access. This is protected by the VCB lock.
//
ASSERT (NpIsAcquiredExclusiveVcb(NpVcb));
if (NT_SUCCESS(Iosb.Status = IoCheckShareAccess( DesiredAccess,
ShareAccess,
FileObject,
&NpVcb->ShareAccess,
TRUE ))) {
//
// Have the file object point back to the Vcb, and increment the
// open count. The pipe end on the call to set file object really
// doesn't matter.
//
NpSetFileObject( FileObject, NpVcb, NULL, FILE_PIPE_CLIENT_END );
NpVcb->OpenCount += 1;
//
// Set our return status
//
Iosb.Status = STATUS_SUCCESS;
Iosb.Information = FILE_OPENED;
}
//
// And return to our caller
//
return Iosb;
}
//
// Internal support routine
//
IO_STATUS_BLOCK
NpOpenNamedPipeRootDirectory(
IN PROOT_DCB RootDcb,
IN PFILE_OBJECT FileObject,
IN ACCESS_MASK DesiredAccess,
IN USHORT ShareAccess,
IN PLIST_ENTRY DeferredList
)
{
IO_STATUS_BLOCK Iosb={0};
PROOT_DCB_CCB Ccb;
PAGED_CODE();
DebugTrace(+1, Dbg, "NpOpenNamedPipeRootDirectory, RootDcb = %08lx\n", RootDcb);
Iosb.Status = NpCreateRootDcbCcb (&Ccb);
if (!NT_SUCCESS(Iosb.Status)) {
return Iosb;
}
//
// Set the new share access, Check we are synchronized.0
//
ASSERT (NpIsAcquiredExclusiveVcb(NpVcb));
if (!NT_SUCCESS(Iosb.Status = IoCheckShareAccess( DesiredAccess,
ShareAccess,
FileObject,
&RootDcb->Specific.Dcb.ShareAccess,
TRUE ))) {
DebugTrace(0, Dbg, "bad share access\n", 0);
NpDeleteCcb ((PCCB) Ccb, DeferredList);
return Iosb;
}
//
// Have the file object point back to the Dcb, and reference the root
// dcb, ccb, and increment our open count. The pipe end on the
// call to set file object really doesn't matter.
//
NpSetFileObject( FileObject,
RootDcb,
Ccb,
FILE_PIPE_CLIENT_END );
RootDcb->OpenCount += 1;
//
// Set our return status
//
Iosb.Status = STATUS_SUCCESS;
Iosb.Information = FILE_OPENED;
DebugTrace(-1, Dbg, "NpOpenNamedPipeRootDirectory -> Iosb.Status = %08lx\n", Iosb.Status);
//
// And return to our caller
//
return Iosb;
}
Reference in a new issue Copy permalink