mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
456 lines
12 KiB
456 lines
12 KiB
/*++
|
|
|
|
Copyright (c) 1989 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
lpccreat.c
|
|
|
|
Abstract:
|
|
|
|
Local Inter-Process Communication (LPC) connection system services.
|
|
|
|
Author:
|
|
|
|
Steve Wood (stevewo) 15-May-1989
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "lpcp.h"
|
|
|
|
//
|
|
// Local procedure prototype
|
|
//
|
|
|
|
NTSTATUS
|
|
LpcpCreatePort (
|
|
OUT PHANDLE PortHandle,
|
|
IN POBJECT_ATTRIBUTES ObjectAttributes,
|
|
IN ULONG MaxConnectionInfoLength,
|
|
IN ULONG MaxMessageLength,
|
|
IN ULONG MaxPoolUsage,
|
|
IN BOOLEAN Waitable
|
|
);
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE,NtCreatePort)
|
|
#pragma alloc_text(PAGE,NtCreateWaitablePort)
|
|
#pragma alloc_text(PAGE,LpcpCreatePort)
|
|
#endif
|
|
|
|
|
|
NTSTATUS
|
|
NtCreatePort (
|
|
OUT PHANDLE PortHandle,
|
|
IN POBJECT_ATTRIBUTES ObjectAttributes,
|
|
IN ULONG MaxConnectionInfoLength,
|
|
IN ULONG MaxMessageLength,
|
|
IN ULONG MaxPoolUsage
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
See LpcpCreatePort.
|
|
|
|
Arguments:
|
|
|
|
See LpcpCreatePort.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - An appropriate status value
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status;
|
|
|
|
PAGED_CODE();
|
|
|
|
Status = LpcpCreatePort( PortHandle,
|
|
ObjectAttributes,
|
|
MaxConnectionInfoLength,
|
|
MaxMessageLength,
|
|
MaxPoolUsage,
|
|
FALSE );
|
|
|
|
return Status ;
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
NtCreateWaitablePort (
|
|
OUT PHANDLE PortHandle,
|
|
IN POBJECT_ATTRIBUTES ObjectAttributes,
|
|
IN ULONG MaxConnectionInfoLength,
|
|
IN ULONG MaxMessageLength,
|
|
IN ULONG MaxPoolUsage
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Same as NtCreatePort.
|
|
|
|
The only difference between this call and NtCreatePort is that the
|
|
working KEVENT that can be used to wait for LPC messages to arrive
|
|
asynchronously.
|
|
|
|
Arguments:
|
|
|
|
See LpcpCreatePort.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - An appropriate status value
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status ;
|
|
|
|
PAGED_CODE();
|
|
|
|
Status = LpcpCreatePort( PortHandle,
|
|
ObjectAttributes,
|
|
MaxConnectionInfoLength,
|
|
MaxMessageLength,
|
|
MaxPoolUsage,
|
|
TRUE );
|
|
|
|
return Status ;
|
|
}
|
|
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
NTSTATUS
|
|
LpcpCreatePort (
|
|
OUT PHANDLE PortHandle,
|
|
IN POBJECT_ATTRIBUTES ObjectAttributes,
|
|
IN ULONG MaxConnectionInfoLength,
|
|
IN ULONG MaxMessageLength,
|
|
IN ULONG MaxPoolUsage,
|
|
IN BOOLEAN Waitable
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
A server process can create a named connection port with the NtCreatePort
|
|
service.
|
|
|
|
A connection port is created with the name and SECURITY_DESCRIPTOR
|
|
specified in the ObjectAttributes structure. A handle to the connection
|
|
port object is returned in the location pointed to by the PortHandle
|
|
parameter. The returned handle can then be used to listen for connection
|
|
requests to that port name, using the NtListenPort service.
|
|
|
|
The standard object architecture defined desired access parameter is not
|
|
necessary since this service can only create a new port, not access an
|
|
existing port.
|
|
|
|
Connection ports cannot be used to send and receive messages. They are
|
|
only valid as a parameter to the NtListenPort service.
|
|
|
|
Arguments:
|
|
|
|
PortHandle - A pointer to a variable that will receive the connection port
|
|
object handle value.
|
|
|
|
ObjectAttributes - A pointer to a structure that specifies the name of the
|
|
object, an access control list (SECURITY_DESCRIPTOR) to be applied to
|
|
the object, and a set of object attribute flags.
|
|
|
|
PUNICODE_STRING ObjectName - An optional pointer to a null terminated
|
|
port name string. The form of the name is
|
|
[\name...\name]\port_name. If no name is specified then an
|
|
unconnected communication port is created rather than a connection
|
|
port. This is useful for sending and receiving messages between
|
|
threads of a single process.
|
|
|
|
ULONG Attributes - A set of flags that control the port object
|
|
attributes.
|
|
|
|
None of the standard values are relevant for this call.
|
|
Connection ports cannot be inherited, are always placed in the
|
|
system handle table and are exclusive to the creating process.
|
|
This field must be zero. Future implementations might support
|
|
specifying the OBJ_PERMANENT attribute.
|
|
|
|
MaxMessageLength - Specifies the maximum length of messages sent or
|
|
received on communication ports created from this connection
|
|
port. The value of this parameter cannot exceed
|
|
MAX_PORTMSG_LENGTH bytes.
|
|
|
|
MaxPoolUsage - Specifies the maximum amount of NonPaged pool used for
|
|
message storage.
|
|
|
|
Waitable - Specifies if the event used by the port can be use to wait
|
|
for LPC messages to arrive asynchronously.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - An appropriate status value
|
|
|
|
--*/
|
|
|
|
{
|
|
PLPCP_PORT_OBJECT ConnectionPort;
|
|
HANDLE Handle;
|
|
KPROCESSOR_MODE PreviousMode;
|
|
NTSTATUS Status;
|
|
PUNICODE_STRING NamePtr;
|
|
UNICODE_STRING CapturedObjectName;
|
|
|
|
PAGED_CODE();
|
|
|
|
UNREFERENCED_PARAMETER (MaxPoolUsage);
|
|
|
|
//
|
|
// Get previous processor mode and probe output arguments if necessary.
|
|
//
|
|
|
|
PreviousMode = KeGetPreviousMode();
|
|
RtlInitUnicodeString( &CapturedObjectName, NULL );
|
|
|
|
if (PreviousMode != KernelMode) {
|
|
|
|
try {
|
|
|
|
ProbeForWriteHandle( PortHandle );
|
|
|
|
ProbeForReadSmallStructure( ObjectAttributes,
|
|
sizeof( OBJECT_ATTRIBUTES ),
|
|
sizeof( ULONG ));
|
|
|
|
NamePtr = ObjectAttributes->ObjectName;
|
|
|
|
if (NamePtr != NULL) {
|
|
|
|
CapturedObjectName = ProbeAndReadStructure( NamePtr,
|
|
UNICODE_STRING );
|
|
}
|
|
|
|
} except( EXCEPTION_EXECUTE_HANDLER ) {
|
|
|
|
return( GetExceptionCode() );
|
|
}
|
|
|
|
} else {
|
|
|
|
if (ObjectAttributes->ObjectName != NULL) {
|
|
|
|
CapturedObjectName = *(ObjectAttributes->ObjectName);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Make the null buffer indicate an unspecified port name
|
|
//
|
|
|
|
if (CapturedObjectName.Length == 0) {
|
|
|
|
CapturedObjectName.Buffer = NULL;
|
|
}
|
|
|
|
//
|
|
// Allocate and initialize a port object. If an object name was
|
|
// specified, then this is a connection port. Otherwise this is an
|
|
// unconnected communication port that a process can use to communicate
|
|
// between threads.
|
|
//
|
|
|
|
Status = ObCreateObject( PreviousMode,
|
|
(Waitable ? LpcWaitablePortObjectType
|
|
: LpcPortObjectType),
|
|
ObjectAttributes,
|
|
PreviousMode,
|
|
NULL,
|
|
(Waitable ? sizeof( LPCP_PORT_OBJECT )
|
|
: FIELD_OFFSET( LPCP_PORT_OBJECT, WaitEvent )),
|
|
0,
|
|
0,
|
|
(PVOID *)&ConnectionPort );
|
|
|
|
if (!NT_SUCCESS( Status )) {
|
|
|
|
return( Status );
|
|
}
|
|
|
|
//
|
|
// Zero out the connection port object and then initialize its fields
|
|
//
|
|
|
|
RtlZeroMemory( ConnectionPort, (Waitable ? sizeof( LPCP_PORT_OBJECT )
|
|
: FIELD_OFFSET( LPCP_PORT_OBJECT, WaitEvent )));
|
|
|
|
ConnectionPort->ConnectionPort = ConnectionPort;
|
|
ConnectionPort->Creator = PsGetCurrentThread()->Cid;
|
|
|
|
InitializeListHead( &ConnectionPort->LpcReplyChainHead );
|
|
|
|
InitializeListHead( &ConnectionPort->LpcDataInfoChainHead );
|
|
|
|
//
|
|
// Named ports get a connection message queue.
|
|
//
|
|
|
|
if (CapturedObjectName.Buffer == NULL) {
|
|
|
|
ConnectionPort->Flags = UNCONNECTED_COMMUNICATION_PORT;
|
|
ConnectionPort->ConnectedPort = ConnectionPort;
|
|
ConnectionPort->ServerProcess = NULL;
|
|
|
|
} else {
|
|
|
|
ConnectionPort->Flags = SERVER_CONNECTION_PORT;
|
|
|
|
ObReferenceObject( PsGetCurrentProcess() );
|
|
ConnectionPort->ServerProcess = PsGetCurrentProcess();
|
|
}
|
|
|
|
if ( Waitable ) {
|
|
|
|
ConnectionPort->Flags |= PORT_WAITABLE;
|
|
}
|
|
|
|
//
|
|
// All ports get a request message queue.
|
|
//
|
|
|
|
Status = LpcpInitializePortQueue( ConnectionPort );
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
|
|
ObDereferenceObject( ConnectionPort );
|
|
|
|
return(Status);
|
|
}
|
|
|
|
//
|
|
// For a waitable port, create the KEVENT that will
|
|
// be used to signal clients
|
|
//
|
|
|
|
if (ConnectionPort->Flags & PORT_WAITABLE) {
|
|
|
|
KeInitializeEvent( &ConnectionPort->WaitEvent,
|
|
NotificationEvent,
|
|
FALSE );
|
|
}
|
|
|
|
//
|
|
// Set the maximum message length and connection info length based on the
|
|
// zone block size less the structs overhead.
|
|
//
|
|
|
|
ConnectionPort->MaxMessageLength = (USHORT) (LpcpGetMaxMessageLength() -
|
|
FIELD_OFFSET( LPCP_MESSAGE, Request ));
|
|
|
|
ConnectionPort->MaxConnectionInfoLength = (USHORT) (ConnectionPort->MaxMessageLength -
|
|
sizeof( PORT_MESSAGE ) -
|
|
sizeof( LPCP_CONNECTION_MESSAGE ));
|
|
|
|
#if DBG
|
|
LpcpTrace(( "Created port %ws (%x) - MaxMsgLen == %x MaxConnectInfoLen == %x\n",
|
|
CapturedObjectName.Buffer == NULL ? L"** UnNamed **" : ObjectAttributes->ObjectName->Buffer,
|
|
ConnectionPort,
|
|
ConnectionPort->MaxMessageLength,
|
|
ConnectionPort->MaxConnectionInfoLength ));
|
|
#endif
|
|
|
|
//
|
|
// Sanity check that the max message length being asked for is not
|
|
// greater than the max message length possible in the system
|
|
//
|
|
|
|
if (ConnectionPort->MaxMessageLength < MaxMessageLength) {
|
|
|
|
#if DBG
|
|
LpcpPrint(( "MaxMessageLength granted is %x but requested %x\n",
|
|
ConnectionPort->MaxMessageLength,
|
|
MaxMessageLength ));
|
|
DbgBreakPoint();
|
|
#endif
|
|
|
|
ObDereferenceObject( ConnectionPort );
|
|
|
|
return STATUS_INVALID_PARAMETER_4;
|
|
}
|
|
|
|
//
|
|
// Save the MaxMessageLength to the connection port
|
|
//
|
|
|
|
ConnectionPort->MaxMessageLength = (USHORT) MaxMessageLength;
|
|
|
|
//
|
|
// Sanity check that the max connection info length being asked for is
|
|
// not greater than the maximum possible in the system
|
|
//
|
|
|
|
if (ConnectionPort->MaxConnectionInfoLength < MaxConnectionInfoLength) {
|
|
|
|
#if DBG
|
|
LpcpPrint(( "MaxConnectionInfoLength granted is %x but requested %x\n",
|
|
ConnectionPort->MaxConnectionInfoLength,
|
|
MaxConnectionInfoLength ));
|
|
DbgBreakPoint();
|
|
#endif
|
|
|
|
ObDereferenceObject( ConnectionPort );
|
|
|
|
return STATUS_INVALID_PARAMETER_3;
|
|
}
|
|
|
|
//
|
|
// Insert connection port object in specified object table. Set port
|
|
// handle value if successful. If not successful, then the port will
|
|
// have been dereferenced, which will cause it to be freed, after our
|
|
// delete procedure is called. The delete procedure will undo the work
|
|
// done to initialize the port. Finally, return the system server status.
|
|
//
|
|
|
|
Status = ObInsertObject( ConnectionPort,
|
|
NULL,
|
|
PORT_ALL_ACCESS,
|
|
0,
|
|
(PVOID *)NULL,
|
|
&Handle );
|
|
|
|
if (NT_SUCCESS( Status )) {
|
|
|
|
//
|
|
// Set the output variable protected against access faults
|
|
//
|
|
|
|
try {
|
|
|
|
*PortHandle = Handle;
|
|
|
|
} except( EXCEPTION_EXECUTE_HANDLER ) {
|
|
|
|
NtClose( Handle );
|
|
|
|
Status = GetExceptionCode();
|
|
}
|
|
}
|
|
|
|
//
|
|
// And return to our caller
|
|
//
|
|
|
|
return Status;
|
|
}
|
|
|
|
|