lpc.h File Reference

#include "lpc_x.h"

Include dependency graph for lpc.h:

Go to the source code of this file.

Classes
struct	_LPCP_DATA_INFO

Macros
#define	_LPC_DEBUG_   0x00
#define	LPC_CREATE_DEBUG   0x01
#define	LPC_CLOSE_DEBUG   0x02
#define	LPC_CONNECT_DEBUG   0x04
#define	LPC_LISTEN_DEBUG   0x08
#define	LPC_REPLY_DEBUG   0x10
#define	LPC_COMPLETE_DEBUG   0x20
#define	LPC_SEND_DEBUG   0x40
#define	LPCTRACE(x, fmt, ...)   DPRINT(fmt, ##__VA_ARGS__)
#define	LPCP_THREAD_FLAG_IS_PORT   1
#define	LPCP_THREAD_FLAG_NO_IMPERSONATION   2
#define	LPCP_THREAD_FLAGS
#define	LPCP_LOCK_HELD   1
#define	LPCP_LOCK_RELEASE   2

Typedefs
typedef struct _LPCP_DATA_INFO	LPCP_DATA_INFO
typedef struct _LPCP_DATA_INFO *	PLPCP_DATA_INFO

Functions
VOID NTAPI	LpcpClosePort (IN PEPROCESS Process OPTIONAL, IN PVOID Object, IN ACCESS_MASK GrantedAccess, IN ULONG ProcessHandleCount, IN ULONG SystemHandleCount)
VOID NTAPI	LpcpDeletePort (IN PVOID ObjectBody)
NTSTATUS NTAPI	LpcpInitializePortQueue (IN PLPCP_PORT_OBJECT Port)
VOID NTAPI	LpcpFreeToPortZone (IN PLPCP_MESSAGE Message, IN ULONG LockFlags)
VOID NTAPI	LpcpMoveMessage (IN PPORT_MESSAGE Destination, IN PPORT_MESSAGE Origin, IN PVOID Data, IN ULONG MessageType, IN PCLIENT_ID ClientId)
VOID NTAPI	LpcpSaveDataInfoMessage (IN PLPCP_PORT_OBJECT Port, IN PLPCP_MESSAGE Message, IN ULONG LockFlags)
VOID NTAPI	LpcExitThread (IN PETHREAD Thread)
BOOLEAN NTAPI	LpcInitSystem (VOID)
BOOLEAN NTAPI	LpcpValidateClientPort (PETHREAD ClientThread, PLPCP_PORT_OBJECT Port)

Variables
POBJECT_TYPE	LpcPortObjectType
ULONG	LpcpNextMessageId
ULONG	LpcpNextCallbackId
KGUARDED_MUTEX	LpcpLock
PAGED_LOOKASIDE_LIST	LpcpMessagesLookaside
ULONG	LpcpMaxMessageSize
ULONG	LpcpTraceLevel

Macro Definition Documentation

_LPC_DEBUG_

#define _LPC_DEBUG_   0x00

Definition at line 12 of file lpc.h.

LPC_CLOSE_DEBUG

#define LPC_CLOSE_DEBUG   0x02

Definition at line 18 of file lpc.h.

LPC_COMPLETE_DEBUG

#define LPC_COMPLETE_DEBUG   0x20

Definition at line 22 of file lpc.h.

LPC_CONNECT_DEBUG

#define LPC_CONNECT_DEBUG   0x04

Definition at line 19 of file lpc.h.

LPC_CREATE_DEBUG

#define LPC_CREATE_DEBUG   0x01

Definition at line 17 of file lpc.h.

LPC_LISTEN_DEBUG

#define LPC_LISTEN_DEBUG   0x08

Definition at line 20 of file lpc.h.

LPC_REPLY_DEBUG

#define LPC_REPLY_DEBUG   0x10

Definition at line 21 of file lpc.h.

LPC_SEND_DEBUG

#define LPC_SEND_DEBUG   0x40

Definition at line 23 of file lpc.h.

LPCP_LOCK_HELD

#define LPCP_LOCK_HELD   1

Definition at line 63 of file lpc.h.

LPCP_LOCK_RELEASE

#define LPCP_LOCK_RELEASE   2

Definition at line 64 of file lpc.h.

LPCP_THREAD_FLAG_IS_PORT

#define LPCP_THREAD_FLAG_IS_PORT   1

Definition at line 55 of file lpc.h.

LPCP_THREAD_FLAG_NO_IMPERSONATION

#define LPCP_THREAD_FLAG_NO_IMPERSONATION   2

Definition at line 56 of file lpc.h.

LPCP_THREAD_FLAGS

#define LPCP_THREAD_FLAGS

Value:

                                                             (LPCP_THREAD_FLAG_IS_PORT | \
                                                             LPCP_THREAD_FLAG_NO_IMPERSONATION)

Definition at line 57 of file lpc.h.

LPCTRACE

#define LPCTRACE	(		x,
			fmt,
			...
	)		DPRINT(fmt, ##__VA_ARGS__)

Definition at line 49 of file lpc.h.

Typedef Documentation

LPCP_DATA_INFO

typedef struct _LPCP_DATA_INFO LPCP_DATA_INFO

PLPCP_DATA_INFO

typedef struct _LPCP_DATA_INFO * PLPCP_DATA_INFO

Function Documentation

LpcExitThread()

VOID NTAPI LpcExitThread

(

IN PETHREAD

Thread

)

Definition at line 19 of file close.c.

{
    PLPCP_MESSAGE Message;
    ASSERT(Thread == PsGetCurrentThread());
 
    /* Acquire the lock */
    KeAcquireGuardedMutex(&LpcpLock);
 
    /* Make sure that the Reply Chain is empty */
    if (!IsListEmpty(&Thread->LpcReplyChain))
    {
        /* It's not, remove the entry */
        RemoveEntryList(&Thread->LpcReplyChain);
    }
 
    /* Set the thread in exit mode */
    Thread->LpcExitThreadCalled = TRUE;
    Thread->LpcReplyMessageId = 0;
 
    /* Check if there's a reply message */
    Message = LpcpGetMessageFromThread(Thread);
    if (Message)
    {
        /* FIXME: TODO */
        ASSERT(FALSE);
    }
 
    /* Release the lock */
    KeReleaseGuardedMutex(&LpcpLock);
}

Referenced by PspExitThread().

LpcInitSystem()

BOOLEAN NTAPI LpcInitSystem

(

VOID

)

Definition at line 37 of file port.c.

{
    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
    UNICODE_STRING Name;
 
    /* Setup the LPC Lock */
    KeInitializeGuardedMutex(&LpcpLock);
 
    /* Create the Port Object Type */
    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
    RtlInitUnicodeString(&Name, L"Port");
    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(LPCP_NONPAGED_PORT_QUEUE);
    ObjectTypeInitializer.DefaultPagedPoolCharge = FIELD_OFFSET(LPCP_PORT_OBJECT, WaitEvent);
    ObjectTypeInitializer.GenericMapping = LpcpPortMapping;
    ObjectTypeInitializer.PoolType = PagedPool;
    ObjectTypeInitializer.UseDefaultObject = TRUE;
    ObjectTypeInitializer.CloseProcedure = LpcpClosePort;
    ObjectTypeInitializer.DeleteProcedure = LpcpDeletePort;
    ObjectTypeInitializer.ValidAccessMask = PORT_ALL_ACCESS;
    ObjectTypeInitializer.InvalidAttributes = OBJ_VALID_ATTRIBUTES & ~OBJ_CASE_INSENSITIVE;
    ObCreateObjectType(&Name,
                       &ObjectTypeInitializer,
                       NULL,
                       &LpcPortObjectType);
 
    /* Create the Waitable Port Object Type */
    RtlInitUnicodeString(&Name, L"WaitablePort");
    ObjectTypeInitializer.PoolType = NonPagedPool;
    ObjectTypeInitializer.DefaultNonPagedPoolCharge += sizeof(LPCP_PORT_OBJECT);
    ObjectTypeInitializer.DefaultPagedPoolCharge = 0;
    ObjectTypeInitializer.UseDefaultObject = FALSE;
    ObCreateObjectType(&Name,
                       &ObjectTypeInitializer,
                       NULL,
                       &LpcWaitablePortObjectType);
 
    /* Allocate the LPC lookaside list */
    LpcpMaxMessageSize = LPCP_MAX_MESSAGE_SIZE;
    ExInitializePagedLookasideList(&LpcpMessagesLookaside,
                                   NULL,
                                   NULL,
                                   0,
                                   LpcpMaxMessageSize,
                                   'McpL',
                                   32);
 
    /* We're done */
    return TRUE;
}

Referenced by Phase1InitializationDiscard().

LpcpClosePort()

VOID NTAPI LpcpClosePort	(	IN PEPROCESS Process	OPTIONAL,
		IN PVOID	Object,
		IN ACCESS_MASK	GrantedAccess,
		IN ULONG	ProcessHandleCount,
		IN ULONG	SystemHandleCount
	)

Definition at line 244 of file close.c.

{
    PLPCP_PORT_OBJECT Port = (PLPCP_PORT_OBJECT)Object;
 
    LPCTRACE(LPC_CLOSE_DEBUG, "Port: %p. Flags: %lx\n", Port, Port->Flags);
 
    /* Only Server-side Connection Ports need clean up*/
    if ((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_CONNECTION_PORT)
    {
        /* Check the handle count */
        switch (SystemHandleCount)
        {
            /* No handles left */
            case 0:
 
                /* Destroy the port queue */
                LpcpDestroyPortQueue(Port, TRUE);
                break;
 
            /* Last handle remaining */
            case 1:
 
                /* Reset the queue only */
                LpcpDestroyPortQueue(Port, FALSE);
 
            /* More handles remain, do nothing */
            default:
                break;
        }
    }
}

Referenced by LpcInitSystem().

LpcpDeletePort()

VOID NTAPI LpcpDeletePort

(

IN PVOID

ObjectBody

)

Definition at line 302 of file close.c.

{
    LARGE_INTEGER Timeout;
    PETHREAD Thread;
    PLPCP_PORT_OBJECT Port = (PLPCP_PORT_OBJECT)ObjectBody;
    PLPCP_PORT_OBJECT ConnectionPort;
    PLPCP_MESSAGE Message;
    PLIST_ENTRY ListHead, NextEntry;
    HANDLE Pid;
    CLIENT_DIED_MSG ClientDiedMsg;
 
    PAGED_CODE();
    LPCTRACE(LPC_CLOSE_DEBUG, "Port: %p. Flags: %lx\n", Port, Port->Flags);
 
    Timeout.QuadPart = -1000000;
 
    /* Check if this is a communication port */
    if ((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_COMMUNICATION_PORT)
    {
        /* Acquire the lock */
        KeAcquireGuardedMutex(&LpcpLock);
 
        /* Get the thread */
        Thread = Port->ClientThread;
        if (Thread)
        {
            /* Clear it */
            Port->ClientThread = NULL;
 
            /* Release the lock and dereference */
            KeReleaseGuardedMutex(&LpcpLock);
            ObDereferenceObject(Thread);
        }
        else
        {
            /* Release the lock */
            KeReleaseGuardedMutex(&LpcpLock);
        }
    }
 
    /* Check if this is a client-side port */
    if ((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_CLIENT_PORT)
    {
        /* Setup the client died message */
        ClientDiedMsg.h.u1.s1.TotalLength = sizeof(ClientDiedMsg);
        ClientDiedMsg.h.u1.s1.DataLength = sizeof(ClientDiedMsg.CreateTime);
        ClientDiedMsg.h.u2.ZeroInit = 0;
        ClientDiedMsg.h.u2.s2.Type = LPC_PORT_CLOSED;
        ClientDiedMsg.CreateTime = PsGetCurrentProcess()->CreateTime;
 
        /* Send it */
        for (;;)
        {
            /* Send the message */
            if (LpcRequestPort(Port, &ClientDiedMsg.h) != STATUS_NO_MEMORY)
                break;
 
            /* Wait until trying again */
            KeDelayExecutionThread(KernelMode, FALSE, &Timeout);
        }
    }
 
    /* Destroy the port queue */
    LpcpDestroyPortQueue(Port, TRUE);
 
    /* Check if we had views */
    if ((Port->ClientSectionBase) || (Port->ServerSectionBase))
    {
        /* Check if we had a client view */
        if (Port->ClientSectionBase)
        {
            /* Unmap it */
            MmUnmapViewOfSection(Port->MappingProcess,
                                 Port->ClientSectionBase);
        }
 
        /* Check for a server view */
        if (Port->ServerSectionBase)
        {
            /* Unmap it */
            MmUnmapViewOfSection(Port->MappingProcess,
                                 Port->ServerSectionBase);
        }
 
        /* Dereference the mapping process */
        ObDereferenceObject(Port->MappingProcess);
        Port->MappingProcess = NULL;
    }
 
    /* Acquire the lock */
    KeAcquireGuardedMutex(&LpcpLock);
 
    /* Get the connection port */
    ConnectionPort = Port->ConnectionPort;
    if (ConnectionPort)
    {
        /* Get the PID */
        Pid = PsGetCurrentProcessId();
 
        /* Loop the data lists */
        ListHead = &ConnectionPort->LpcDataInfoChainHead;
        NextEntry = ListHead->Flink;
        while (NextEntry != ListHead)
        {
            /* Get the message */
            Message = CONTAINING_RECORD(NextEntry, LPCP_MESSAGE, Entry);
            NextEntry = NextEntry->Flink;
 
            /* Check if this is the connection port */
            if (Port == ConnectionPort)
            {
                /* Free queued messages */
                RemoveEntryList(&Message->Entry);
                InitializeListHead(&Message->Entry);
                LpcpFreeToPortZone(Message, LPCP_LOCK_HELD);
 
                /* Restart at the head */
                NextEntry = ListHead->Flink;
            }
            else if ((Message->Request.ClientId.UniqueProcess == Pid) &&
                     ((Message->SenderPort == Port) ||
                      (Message->SenderPort == Port->ConnectedPort) ||
                      (Message->SenderPort == ConnectionPort)))
            {
                /* Remove it */
                RemoveEntryList(&Message->Entry);
                InitializeListHead(&Message->Entry);
                LpcpFreeToPortZone(Message, LPCP_LOCK_HELD);
 
                /* Restart at the head */
                NextEntry = ListHead->Flink;
            }
        }
 
        /* Release the lock */
        KeReleaseGuardedMutex(&LpcpLock);
 
        /* Dereference the object unless it's the same port */
        if (ConnectionPort != Port) ObDereferenceObject(ConnectionPort);
 
        /* Check if this is a connection port with a server process */
        if (((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_CONNECTION_PORT) &&
            (ConnectionPort->ServerProcess))
        {
            /* Dereference the server process */
            ObDereferenceObject(ConnectionPort->ServerProcess);
            ConnectionPort->ServerProcess = NULL;
        }
    }
    else
    {
        /* Release the lock */
        KeReleaseGuardedMutex(&LpcpLock);
    }
 
    /* Free client security */
    LpcpFreePortClientSecurity(Port);
    LPCTRACE(LPC_CLOSE_DEBUG, "Port: %p deleted\n", Port);
}

Referenced by LpcInitSystem().

LpcpFreeToPortZone()

VOID NTAPI LpcpFreeToPortZone	(	IN PLPCP_MESSAGE	Message,
		IN ULONG	LockFlags
	)

Definition at line 52 of file close.c.

{
    PLPCP_CONNECTION_MESSAGE ConnectMessage;
    PLPCP_PORT_OBJECT ClientPort = NULL;
    PETHREAD Thread = NULL;
    BOOLEAN LockHeld = (LockFlags & LPCP_LOCK_HELD);
    BOOLEAN ReleaseLock = (LockFlags & LPCP_LOCK_RELEASE);
 
    PAGED_CODE();
 
    LPCTRACE(LPC_CLOSE_DEBUG, "Message: %p. LockFlags: %lx\n", Message, LockFlags);
 
    /* Acquire the lock if not already */
    if (!LockHeld) KeAcquireGuardedMutex(&LpcpLock);
 
    /* Check if the queue list is empty */
    if (!IsListEmpty(&Message->Entry))
    {
        /* Remove and re-initialize */
        RemoveEntryList(&Message->Entry);
        InitializeListHead(&Message->Entry);
    }
 
    /* Check if we've already replied */
    if (Message->RepliedToThread)
    {
        /* Set thread to dereference and clean up */
        Thread = Message->RepliedToThread;
        Message->RepliedToThread = NULL;
    }
 
    /* Check if this is a connection request */
    if (Message->Request.u2.s2.Type == LPC_CONNECTION_REQUEST)
    {
        /* Get the connection message */
        ConnectMessage = (PLPCP_CONNECTION_MESSAGE)(Message + 1);
 
        /* Clear the client port */
        ClientPort = ConnectMessage->ClientPort;
        if (ClientPort) ConnectMessage->ClientPort = NULL;
    }
 
    /* Release the lock */
    KeReleaseGuardedMutex(&LpcpLock);
 
    /* Check if we had anything to dereference */
    if (Thread) ObDereferenceObject(Thread);
    if (ClientPort) ObDereferenceObject(ClientPort);
 
    /* Free the entry */
    ExFreeToPagedLookasideList(&LpcpMessagesLookaside, Message);
 
    /* Reacquire the lock if needed */
    if ((LockHeld) && !(ReleaseLock)) KeAcquireGuardedMutex(&LpcpLock);
}

Referenced by LpcpDeletePort(), LpcpDestroyPortQueue(), LpcpFreeDataInfoMessage(), LpcRequestPort(), LpcRequestWaitReplyPort(), NtReplyPort(), NtReplyWaitReceivePortEx(), NtRequestPort(), NtRequestWaitReplyPort(), and NtSecureConnectPort().

LpcpInitializePortQueue()

NTSTATUS NTAPI LpcpInitializePortQueue

(

IN PLPCP_PORT_OBJECT

Port

)

Definition at line 19 of file create.c.

{
    PLPCP_NONPAGED_PORT_QUEUE MessageQueue;
 
    PAGED_CODE();
 
    /* Allocate the queue */
    MessageQueue = ExAllocatePoolWithTag(NonPagedPool,
                                         sizeof(*MessageQueue),
                                         'troP');
    if (!MessageQueue) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Set it up */
    KeInitializeSemaphore(&MessageQueue->Semaphore, 0, MAXLONG);
    MessageQueue->BackPointer = Port;
 
    /* And link it with the Paged Pool part */
    Port->MsgQueue.Semaphore = &MessageQueue->Semaphore;
    InitializeListHead(&Port->MsgQueue.ReceiveHead);
    return STATUS_SUCCESS;
}

Referenced by LpcpCreatePort(), and NtSecureConnectPort().

LpcpMoveMessage()

VOID NTAPI LpcpMoveMessage	(	IN PPORT_MESSAGE	Destination,
		IN PPORT_MESSAGE	Origin,
		IN PVOID	Data,
		IN ULONG	MessageType,
		IN PCLIENT_ID	ClientId
	)

Definition at line 139 of file reply.c.

{
    LPCTRACE((LPC_REPLY_DEBUG | LPC_SEND_DEBUG),
             "Destination/Origin: %p/%p. Data: %p. Length: %lx\n",
             Destination,
             Origin,
             Data,
             Origin->u1.Length);
 
    /* Set the Message size */
    Destination->u1.Length = Origin->u1.Length;
 
    /* Set the Message Type */
    Destination->u2.s2.Type = !MessageType ?
                              Origin->u2.s2.Type : MessageType & 0xFFFF;
 
    /* Check if we have a Client ID */
    if (ClientId)
    {
        /* Set the Client ID */
        Destination->ClientId.UniqueProcess = ClientId->UniqueProcess;
        Destination->ClientId.UniqueThread = ClientId->UniqueThread;
    }
    else
    {
        /* Otherwise, copy it */
        Destination->ClientId.UniqueProcess = Origin->ClientId.UniqueProcess;
        Destination->ClientId.UniqueThread = Origin->ClientId.UniqueThread;
    }
 
    /* Copy the MessageId and ClientViewSize */
    Destination->MessageId = Origin->MessageId;
    Destination->ClientViewSize = Origin->ClientViewSize;
 
    /* Copy the Message Data */
    RtlCopyMemory(Destination + 1,
                  Data,
                  ALIGN_UP_BY(Destination->u1.s1.DataLength, sizeof(ULONG)));
}

Referenced by LpcRequestPort(), LpcRequestWaitReplyPort(), NtReplyPort(), NtReplyWaitReceivePortEx(), NtRequestPort(), and NtRequestWaitReplyPort().

LpcpSaveDataInfoMessage()

VOID NTAPI LpcpSaveDataInfoMessage	(	IN PLPCP_PORT_OBJECT	Port,
		IN PLPCP_MESSAGE	Message,
		IN ULONG	LockFlags
	)

Definition at line 62 of file reply.c.

{
    BOOLEAN LockHeld = (LockFlags & LPCP_LOCK_HELD);
 
    PAGED_CODE();
 
    /* Acquire the lock */
    if (!LockHeld) KeAcquireGuardedMutex(&LpcpLock);
 
    /* Check if the port we want is the connection port */
    if ((Port->Flags & LPCP_PORT_TYPE_MASK) > LPCP_UNCONNECTED_PORT)
    {
        /* Use it */
        Port = Port->ConnectionPort;
        if (!Port)
        {
            /* Release the lock and return */
            if (!LockHeld) KeReleaseGuardedMutex(&LpcpLock);
            return;
        }
    }
 
    /* Link the message */
    InsertTailList(&Port->LpcDataInfoChainHead, &Message->Entry);
 
    /* Release the lock */
    if (!LockHeld) KeReleaseGuardedMutex(&LpcpLock);
}

Referenced by NtReplyWaitReceivePortEx(), and NtRequestWaitReplyPort().

LpcpValidateClientPort()

BOOLEAN NTAPI LpcpValidateClientPort	(	PETHREAD	ClientThread,
		PLPCP_PORT_OBJECT	Port
	)

Definition at line 90 of file port.c.

{
    PLPCP_PORT_OBJECT ThreadPort;
 
    /* Get the thread's port */
    ThreadPort = LpcpGetPortFromThread(ClientThread);
    if (ThreadPort == NULL)
    {
        return FALSE;
    }
 
    /* Check if the port matches directly */
    if ((Port == ThreadPort) ||
        (Port == ThreadPort->ConnectionPort) ||
        (Port == ThreadPort->ConnectedPort))
    {
        return TRUE;
    }
 
    /* Check if this is a communication port and the connection port matches */
    if (((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_COMMUNICATION_PORT) &&
        (Port->ConnectionPort == ThreadPort))
    {
        return TRUE;
    }
 
    return FALSE;
}

Referenced by LpcpCopyRequestData(), and NtImpersonateClientOfPort().

Variable Documentation

LpcpLock

KGUARDED_MUTEX LpcpLock

extern

Definition at line 20 of file port.c.

Referenced by LpcExitThread(), LpcInitSystem(), LpcpAllocateFromPortZone(), LpcpCopyRequestData(), LpcpDeletePort(), LpcpDestroyPortQueue(), LpcpFreeConMsg(), LpcpFreeToPortZone(), LpcpSaveDataInfoMessage(), LpcRequestPort(), LpcRequestWaitReplyPort(), NtAcceptConnectPort(), NtCompleteConnectPort(), NtImpersonateClientOfPort(), NtReplyPort(), NtReplyWaitReceivePortEx(), NtRequestPort(), NtRequestWaitReplyPort(), and NtSecureConnectPort().

LpcpMaxMessageSize

ULONG LpcpMaxMessageSize

extern

Definition at line 18 of file port.c.

Referenced by LpcInitSystem(), and LpcpCreatePort().

LpcpMessagesLookaside

PAGED_LOOKASIDE_LIST LpcpMessagesLookaside

extern

Definition at line 19 of file port.c.

Referenced by LpcInitSystem(), LpcpAllocateFromPortZone(), and LpcpFreeToPortZone().

LpcpNextCallbackId

ULONG LpcpNextCallbackId

Definition at line 158 of file lpc.h.

LpcpNextMessageId

ULONG LpcpNextMessageId

extern

Definition at line 22 of file port.c.

Referenced by LpcRequestPort(), LpcRequestWaitReplyPort(), NtRequestPort(), NtRequestWaitReplyPort(), and NtSecureConnectPort().

LpcPortObjectType

POBJECT_TYPE LpcPortObjectType

extern

Definition at line 17 of file port.c.

Referenced by InitCsrApiPort(), LpcpCopyRequestData(), LpcpCreatePort(), NtCompleteConnectPort(), NtRegisterThreadTerminatePort(), NtReplyPort(), NtReplyWaitReceivePortEx(), NtRequestPort(), NtRequestWaitReplyPort(), NtSecureConnectPort(), NtSetDefaultHardErrorPort(), NtSetInformationProcess(), PspCreateProcess(), and TestObjectTypes().

LpcpTraceLevel

ULONG LpcpTraceLevel

extern

Definition at line 21 of file port.c.