-/* $Id: connect.c,v 1.9 2001/12/31 01:53:45 dwelch Exp $
- *
+/* $Id$
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/lpc/connect.c
* PURPOSE: Communication mechanism
- * PROGRAMMER: David Welch (welch@cwcom.net)
- * UPDATE HISTORY:
- * Created 22/05/98
+ *
+ * PROGRAMMERS: David Welch (welch@cwcom.net)
*/
/* INCLUDES *****************************************************************/
-#include <ddk/ntddk.h>
-#include <internal/ob.h>
-#include <internal/port.h>
-#include <internal/dbg.h>
-#include <internal/pool.h>
-#include <internal/safe.h>
-#include <internal/mm.h>
-
+#include <ntoskrnl.h>
#define NDEBUG
#include <internal/debug.h>
-/* GLOBALS *******************************************************************/
-
-#define TAG_LPC_CONNECT_MESSAGE TAG('L', 'P', 'C', 'C')
-
/* FUNCTIONS *****************************************************************/
+/**********************************************************************
+ * NAME EXPORTED
+ * EiConnectPort/12
+ *
+ * DESCRIPTION
+ *
+ * ARGUMENTS
+ *
+ * RETURN VALUE
+ */
NTSTATUS STDCALL
EiConnectPort(IN PEPORT* ConnectedPort,
IN PEPORT NamedPort,
/*
* Create a port to represent our side of the connection
*/
- Status = ObCreateObject (NULL,
- PORT_ALL_ACCESS,
+ Status = ObCreateObject (KernelMode,
+ LpcPortObjectType,
NULL,
- ExPortType,
+ KernelMode,
+ NULL,
+ sizeof(EPORT),
+ 0,
+ 0,
(PVOID*)&OurPort);
if (!NT_SUCCESS(Status))
{
return (Status);
}
- NiInitializePort(OurPort);
+ LpcpInitializePort(OurPort, EPORT_TYPE_CLIENT_COMM_PORT, NamedPort);
/*
* Allocate a request message.
*/
- RequestMessage = ExAllocatePool(NonPagedPool,
- sizeof(EPORT_CONNECT_REQUEST_MESSAGE) +
+ RequestMessage = ExAllocatePool(NonPagedPool,
+ sizeof(EPORT_CONNECT_REQUEST_MESSAGE) +
RequestConnectDataLength);
if (RequestMessage == NULL)
{
/*
* Initialize the request message.
*/
- RequestMessage->MessageHeader.DataSize =
+ RequestMessage->MessageHeader.u1.s1.DataLength =
sizeof(EPORT_CONNECT_REQUEST_MESSAGE) + RequestConnectDataLength -
- sizeof(LPC_MESSAGE_HEADER);
- RequestMessage->MessageHeader.MessageSize =
+ sizeof(PORT_MESSAGE);
+ RequestMessage->MessageHeader.u1.s1.TotalLength =
sizeof(EPORT_CONNECT_REQUEST_MESSAGE) + RequestConnectDataLength;
DPRINT("RequestMessageSize %d\n",
- RequestMessage->MessageHeader.MessageSize);
- RequestMessage->MessageHeader.SharedSectionSize = 0;
+ RequestMessage->MessageHeader.u1.s1.TotalLength);
+ RequestMessage->MessageHeader.ClientViewSize = 0;
RequestMessage->ConnectingProcess = PsGetCurrentProcess();
ObReferenceObjectByPointer(RequestMessage->ConnectingProcess,
PROCESS_VM_OPERATION,
memcpy(RequestMessage->ConnectData, ConnectData,
RequestConnectDataLength);
}
-
+
/*
* Queue the message to the named port
*/
OurPort);
KeReleaseSemaphore(&NamedPort->Semaphore, IO_NO_INCREMENT, 1, FALSE);
ExFreePool(RequestMessage);
-
+
/*
* Wait for them to accept our connection
*/
FALSE,
NULL);
- /*
+ /*
* Dequeue the response
*/
KeAcquireSpinLock (&OurPort->Lock, &oldIrql);
/*
* Check for connection refusal.
*/
- if (CReply->MessageHeader.MessageType == LPC_CONNECTION_REFUSED)
+ if (CReply->MessageHeader.u2.s2.Type == LPC_CONNECTION_REFUSED)
{
ObDereferenceObject(OurPort);
ExFreePool(Reply);
/**********************************************************************
* NAME EXPORTED
- * NtConnectPort@32
- *
+ * NtConnectPort/8
+ *
* DESCRIPTION
- * Connect to a named port and wait for the other side to
- * accept the connection.
+ * Connect to a named port and wait for the other side to
+ * accept or reject the connection request.
*
* ARGUMENTS
* ConnectedPort
* MaxMessageSize
* ConnectInfo
* UserConnectInfoLength
- *
+ *
* RETURN VALUE
- *
+ *
+ * @unimplemented
*/
NTSTATUS STDCALL
NtConnectPort (PHANDLE UnsafeConnectedPortHandle,
PUNICODE_STRING PortName,
PSECURITY_QUALITY_OF_SERVICE Qos,
- PLPC_SECTION_WRITE UnsafeWriteMap,
- PLPC_SECTION_READ UnsafeReadMap,
+ PPORT_VIEW UnsafeWriteMap,
+ PREMOTE_PORT_VIEW UnsafeReadMap,
PULONG UnsafeMaximumMessageSize,
PVOID UnsafeConnectData,
PULONG UnsafeConnectDataLength)
{
HANDLE ConnectedPortHandle;
- LPC_SECTION_WRITE WriteMap;
- LPC_SECTION_READ ReadMap;
+ PORT_VIEW WriteMap;
+ REMOTE_PORT_VIEW ReadMap;
ULONG MaximumMessageSize;
- PVOID ConnectData;
- ULONG ConnectDataLength;
+ PVOID ConnectData = NULL;
+ ULONG ConnectDataLength = 0;
PSECTION_OBJECT SectionObject;
LARGE_INTEGER SectionOffset;
PEPORT ConnectedPort;
- NTSTATUS Status;
+ KPROCESSOR_MODE PreviousMode;
+ NTSTATUS Status = STATUS_SUCCESS;
PEPORT NamedPort;
+ PreviousMode = ExGetPreviousMode();
+
+ if (PreviousMode != KernelMode)
+ {
+ _SEH_TRY
+ {
+ ProbeForWriteHandle(UnsafeConnectedPortHandle);
+ if (UnsafeMaximumMessageSize != NULL)
+ {
+ ProbeForWriteUlong(UnsafeMaximumMessageSize);
+ }
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
+
+ if (!NT_SUCCESS(Status))
+ {
+ return Status;
+ }
+ }
+
/*
* Copy in write map and partially validate.
*/
if (UnsafeWriteMap != NULL)
{
- Status = MmCopyFromCaller(&WriteMap, UnsafeWriteMap,
- sizeof(LPC_SECTION_WRITE));
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
- if (WriteMap.Length != sizeof(LPC_SECTION_WRITE))
+ if (PreviousMode != KernelMode)
+ {
+ _SEH_TRY
+ {
+ ProbeForWrite(UnsafeWriteMap,
+ sizeof(PORT_VIEW),
+ 1);
+ RtlCopyMemory(&WriteMap,
+ UnsafeWriteMap,
+ sizeof(PORT_VIEW));
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
+
+ if (!NT_SUCCESS(Status))
+ {
+ return Status;
+ }
+ }
+ else
+ {
+ RtlCopyMemory(&WriteMap,
+ UnsafeWriteMap,
+ sizeof(PORT_VIEW));
+ }
+
+ if (WriteMap.Length != sizeof(PORT_VIEW))
{
return(STATUS_INVALID_PARAMETER_4);
}
/*
* Handle connection data.
*/
- if (UnsafeConnectData == NULL)
- {
- ConnectDataLength = 0;
- ConnectData = NULL;
- }
- else
- {
- if (ExGetPreviousMode() == KernelMode)
- {
- ConnectDataLength = *UnsafeConnectDataLength;
- ConnectData = UnsafeConnectData;
- }
+ if (UnsafeConnectData)
+ {
+ if (PreviousMode != KernelMode)
+ {
+ _SEH_TRY
+ {
+ ConnectDataLength = ProbeForReadUlong(UnsafeConnectDataLength);
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
+
+ if (!NT_SUCCESS(Status))
+ {
+ return Status;
+ }
+ }
else
- {
- Status = MmCopyFromCaller(&ConnectDataLength,
- UnsafeConnectDataLength,
- sizeof(ULONG));
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
- ConnectData = ExAllocatePool(NonPagedPool, ConnectDataLength);
- if (ConnectData == NULL && ConnectDataLength != 0)
- {
- return(STATUS_NO_MEMORY);
- }
- Status = MmCopyFromCaller(ConnectData,
- UnsafeConnectData,
- ConnectDataLength);
- if (!NT_SUCCESS(Status))
- {
- ExFreePool(ConnectData);
- return(Status);
- }
- }
+ {
+ ConnectDataLength = *UnsafeConnectDataLength;
+ }
+
+ if (ConnectDataLength != 0)
+ {
+ ConnectData = ExAllocatePool(NonPagedPool, ConnectDataLength);
+ if (ConnectData == NULL)
+ {
+ return(STATUS_NO_MEMORY);
+ }
+
+ if (PreviousMode != KernelMode)
+ {
+ _SEH_TRY
+ {
+ ProbeForWriteUlong(UnsafeConnectData);
+ RtlCopyMemory(ConnectData,
+ UnsafeConnectData,
+ ConnectDataLength);
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
+
+ if (!NT_SUCCESS(Status))
+ {
+ ExFreePool(ConnectData);
+ return Status;
+ }
+ }
+ else
+ {
+ RtlCopyMemory(ConnectData,
+ UnsafeConnectData,
+ ConnectDataLength);
+ }
+ }
}
/*
0,
NULL,
PORT_ALL_ACCESS, /* DesiredAccess */
- ExPortType,
- UserMode,
+ LpcPortObjectType,
+ PreviousMode,
NULL,
(PVOID*)&NamedPort);
if (!NT_SUCCESS(Status))
Status = ObReferenceObjectByHandle(WriteMap.SectionHandle,
SECTION_MAP_READ | SECTION_MAP_WRITE,
MmSectionObjectType,
- UserMode,
+ PreviousMode,
(PVOID*)&SectionObject,
NULL);
if (!NT_SUCCESS(Status))
SectionOffset,
WriteMap.ViewSize,
&WriteMap.ViewBase,
- &WriteMap.TargetViewBase,
+ &WriteMap.ViewRemoteBase,
&ReadMap.ViewSize,
&ReadMap.ViewBase,
&MaximumMessageSize,
/* FIXME: Again, check what NT does here. */
if (UnsafeConnectDataLength != NULL)
{
- if (ExGetPreviousMode() != KernelMode)
+ if (PreviousMode != KernelMode)
{
- MmCopyToCaller(UnsafeConnectData, ConnectData,
- ConnectDataLength);
- ExFreePool(ConnectData);
+ _SEH_TRY
+ {
+ RtlCopyMemory(UnsafeConnectData,
+ ConnectData,
+ ConnectDataLength);
+ *UnsafeConnectDataLength = ConnectDataLength;
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
}
- MmCopyToCaller(UnsafeConnectDataLength, &ConnectDataLength,
- sizeof(ULONG));
+ else
+ {
+ RtlCopyMemory(UnsafeConnectData,
+ ConnectData,
+ ConnectDataLength);
+ *UnsafeConnectDataLength = ConnectDataLength;
+ }
+
+ ExFreePool(ConnectData);
}
return(Status);
}
}
ObDereferenceObject(NamedPort);
NamedPort = NULL;
-
+
/*
* Copy the data back to the caller.
*/
- if (ExGetPreviousMode() != KernelMode)
+
+ if (UnsafeConnectDataLength != NULL)
{
- if (UnsafeConnectDataLength != NULL)
+ if (PreviousMode != KernelMode)
{
- if (ExGetPreviousMode() != KernelMode)
- {
- Status = MmCopyToCaller(UnsafeConnectData, ConnectData,
- ConnectDataLength);
- ExFreePool(ConnectData);
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
- }
- Status = MmCopyToCaller(UnsafeConnectDataLength, &ConnectDataLength,
- sizeof(ULONG));
+ _SEH_TRY
+ {
+ *UnsafeConnectDataLength = ConnectDataLength;
+
+ if (ConnectData != NULL)
+ {
+ RtlCopyMemory(UnsafeConnectData,
+ ConnectData,
+ ConnectDataLength);
+ }
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
+
if (!NT_SUCCESS(Status))
{
- return(Status);
+ if (ConnectData != NULL)
+ {
+ ExFreePool(ConnectData);
+ }
+ return(Status);
}
}
+ else
+ {
+ *UnsafeConnectDataLength = ConnectDataLength;
+
+ if (ConnectData != NULL)
+ {
+ RtlCopyMemory(UnsafeConnectData,
+ ConnectData,
+ ConnectDataLength);
+ }
+ }
+
+ if (ConnectData != NULL)
+ {
+ ExFreePool(ConnectData);
+ }
}
Status = ObInsertObject(ConnectedPort,
NULL,
{
return(Status);
}
- Status = MmCopyToCaller(UnsafeConnectedPortHandle, &ConnectedPortHandle,
- sizeof(HANDLE));
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
- if (UnsafeWriteMap != NULL)
- {
- Status = MmCopyToCaller(UnsafeWriteMap, &WriteMap,
- sizeof(LPC_SECTION_WRITE));
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
- }
- if (UnsafeReadMap != NULL)
- {
- Status = MmCopyToCaller(UnsafeReadMap, &ReadMap,
- sizeof(LPC_SECTION_READ));
+
+ if (PreviousMode != KernelMode)
+ {
+ _SEH_TRY
+ {
+ *UnsafeConnectedPortHandle = ConnectedPortHandle;
+
+ if (UnsafeWriteMap != NULL)
+ {
+ RtlCopyMemory(UnsafeWriteMap,
+ &WriteMap,
+ sizeof(PORT_VIEW));
+ }
+
+ if (UnsafeReadMap != NULL)
+ {
+ RtlCopyMemory(UnsafeReadMap,
+ &ReadMap,
+ sizeof(REMOTE_PORT_VIEW));
+ }
+
+ if (UnsafeMaximumMessageSize != NULL)
+ {
+ *UnsafeMaximumMessageSize = MaximumMessageSize;
+ }
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
+
if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
+ {
+ return Status;
+ }
}
- if (UnsafeMaximumMessageSize != NULL)
+ else
{
- Status = MmCopyToCaller(UnsafeMaximumMessageSize,
- &MaximumMessageSize,
- sizeof(LPC_SECTION_WRITE));
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
+ *UnsafeConnectedPortHandle = ConnectedPortHandle;
+
+ if (UnsafeWriteMap != NULL)
+ {
+ RtlCopyMemory(UnsafeWriteMap,
+ &WriteMap,
+ sizeof(PORT_VIEW));
+ }
+
+ if (UnsafeReadMap != NULL)
+ {
+ RtlCopyMemory(UnsafeReadMap,
+ &ReadMap,
+ sizeof(REMOTE_PORT_VIEW));
+ }
+
+ if (UnsafeMaximumMessageSize != NULL)
+ {
+ *UnsafeMaximumMessageSize = MaximumMessageSize;
+ }
}
/*
* All done.
*/
- ObDereferenceObject(ConnectedPort);
return(STATUS_SUCCESS);
}
/**********************************************************************
* NAME EXPORTED
- * NtAcceptConnectPort@24
+ * NtAcceptConnectPort/6
*
* DESCRIPTION
*
* ReadMap
*
* RETURN VALUE
- *
*/
-EXPORTED NTSTATUS STDCALL
+/*EXPORTED*/ NTSTATUS STDCALL
NtAcceptConnectPort (PHANDLE ServerPortHandle,
HANDLE NamedPortHandle,
- PLPC_MESSAGE LpcMessage,
+ PPORT_MESSAGE LpcMessage,
BOOLEAN AcceptIt,
- PLPC_SECTION_WRITE WriteMap,
- PLPC_SECTION_READ ReadMap)
+ PPORT_VIEW WriteMap,
+ PREMOTE_PORT_VIEW ReadMap)
{
NTSTATUS Status;
PEPORT NamedPort;
KIRQL oldIrql;
PEPORT_CONNECT_REQUEST_MESSAGE CRequest;
PEPORT_CONNECT_REPLY_MESSAGE CReply;
+ ULONG Size;
+ KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- CReply = ExAllocatePool(NonPagedPool,
- sizeof(EPORT_CONNECT_REPLY_MESSAGE) + LpcMessage->DataSize);
+ Size = sizeof(EPORT_CONNECT_REPLY_MESSAGE);
+ if (LpcMessage)
+ {
+ Size += LpcMessage->u1.s1.DataLength;
+ }
+
+ CReply = ExAllocatePool(NonPagedPool, Size);
if (CReply == NULL)
{
return(STATUS_NO_MEMORY);
}
-
+
Status = ObReferenceObjectByHandle(NamedPortHandle,
PORT_ALL_ACCESS,
- ExPortType,
- UserMode,
+ LpcPortObjectType,
+ PreviousMode,
(PVOID*)&NamedPort,
NULL);
if (!NT_SUCCESS(Status))
/*
* Create a port object for our side of the connection
*/
- if (AcceptIt == 1)
+ if (AcceptIt)
{
- Status = ObCreateObject(ServerPortHandle,
- PORT_ALL_ACCESS,
+ Status = ObCreateObject(PreviousMode,
+ LpcPortObjectType,
+ NULL,
+ PreviousMode,
NULL,
- ExPortType,
+ sizeof(EPORT),
+ 0,
+ 0,
(PVOID*)&OurPort);
if (!NT_SUCCESS(Status))
{
+ ExFreePool(CReply);
ObDereferenceObject(NamedPort);
return(Status);
}
- NiInitializePort(OurPort);
+
+ Status = ObInsertObject ((PVOID)OurPort,
+ NULL,
+ PORT_ALL_ACCESS,
+ 0,
+ NULL,
+ ServerPortHandle);
+ if (!NT_SUCCESS(Status))
+ {
+ ObDereferenceObject(OurPort);
+ ExFreePool(CReply);
+ ObDereferenceObject(NamedPort);
+ return(Status);
+ }
+
+ LpcpInitializePort(OurPort, EPORT_TYPE_SERVER_COMM_PORT, NamedPort);
}
-
+
/*
* Dequeue the connection request
*/
ConnectionRequest = EiDequeueConnectMessagePort (NamedPort);
KeReleaseSpinLock(&NamedPort->Lock, oldIrql);
CRequest = (PEPORT_CONNECT_REQUEST_MESSAGE)(&ConnectionRequest->Message);
-
+
/*
* Prepare the reply.
*/
if (LpcMessage != NULL)
{
- memcpy(&CReply->MessageHeader, LpcMessage, sizeof(LPC_MESSAGE_HEADER));
- memcpy(&CReply->ConnectData, (PVOID)(LpcMessage + 1),
- LpcMessage->DataSize);
- CReply->MessageHeader.MessageSize =
- sizeof(EPORT_CONNECT_REPLY_MESSAGE) + LpcMessage->DataSize;
- CReply->MessageHeader.DataSize = CReply->MessageHeader.MessageSize -
- sizeof(LPC_MESSAGE_HEADER);
- CReply->ConnectDataLength = LpcMessage->DataSize;
+ memcpy(&CReply->MessageHeader, LpcMessage, sizeof(PORT_MESSAGE));
+ memcpy(&CReply->ConnectData, (PVOID)(LpcMessage + 1),
+ LpcMessage->u1.s1.DataLength);
+ CReply->MessageHeader.u1.s1.TotalLength =
+ sizeof(EPORT_CONNECT_REPLY_MESSAGE) + LpcMessage->u1.s1.DataLength;
+ CReply->MessageHeader.u1.s1.DataLength = CReply->MessageHeader.u1.s1.TotalLength -
+ sizeof(PORT_MESSAGE);
+ CReply->ConnectDataLength = LpcMessage->u1.s1.DataLength;
}
else
{
- CReply->MessageHeader.MessageSize = sizeof(EPORT_CONNECT_REPLY_MESSAGE);
- CReply->MessageHeader.DataSize = sizeof(EPORT_CONNECT_REPLY_MESSAGE) -
- sizeof(LPC_MESSAGE_HEADER);
+ CReply->MessageHeader.u1.s1.TotalLength = sizeof(EPORT_CONNECT_REPLY_MESSAGE);
+ CReply->MessageHeader.u1.s1.DataLength = sizeof(EPORT_CONNECT_REPLY_MESSAGE) -
+ sizeof(PORT_MESSAGE);
CReply->ConnectDataLength = 0;
}
-
- if (AcceptIt != 1)
- {
+ if (!AcceptIt)
+ {
EiReplyOrRequestPort(ConnectionRequest->Sender,
&CReply->MessageHeader,
LPC_CONNECTION_REFUSED,
1,
FALSE);
ObDereferenceObject(ConnectionRequest->Sender);
- ExFreePool(ConnectionRequest);
+ ExFreePool(ConnectionRequest);
ExFreePool(CReply);
ObDereferenceObject(NamedPort);
return (STATUS_SUCCESS);
}
-
+
/*
* Prepare the connection.
*/
Status = ObReferenceObjectByHandle(WriteMap->SectionHandle,
SECTION_MAP_READ | SECTION_MAP_WRITE,
MmSectionObjectType,
- UserMode,
+ PreviousMode,
(PVOID*)&SectionObject,
NULL);
if (!NT_SUCCESS(Status))
}
SectionOffset.QuadPart = WriteMap->SectionOffset;
- WriteMap->TargetViewBase = 0;
+ WriteMap->ViewRemoteBase = 0;
CReply->ReceiveClientViewSize = WriteMap->ViewSize;
Status = MmMapViewOfSection(SectionObject,
CRequest->ConnectingProcess,
- &WriteMap->TargetViewBase,
+ &WriteMap->ViewRemoteBase,
0,
CReply->ReceiveClientViewSize,
&SectionOffset,
if (!NT_SUCCESS(Status))
{
return(Status);
- }
+ }
WriteMap->ViewBase = 0;
Status = MmMapViewOfSection(SectionObject,
if (!NT_SUCCESS(Status))
{
return(Status);
- }
-
+ }
+
ObDereferenceObject(SectionObject);
}
if (ReadMap != NULL && CRequest->SendSectionObject != NULL)
}
if (WriteMap != NULL)
{
- CReply->ReceiveClientViewBase = WriteMap->TargetViewBase;
+ CReply->ReceiveClientViewBase = WriteMap->ViewRemoteBase;
}
- CReply->MaximumMessageSize = 0x148;
+ CReply->MaximumMessageSize = LPC_MAX_MESSAGE_LENGTH;
+
/*
* Connect the two ports
OurPort->OtherPort = ConnectionRequest->Sender;
OurPort->OtherPort->OtherPort = OurPort;
EiReplyOrRequestPort(ConnectionRequest->Sender,
- LpcMessage,
+ (PPORT_MESSAGE)CReply,
LPC_REPLY,
OurPort);
ExFreePool(ConnectionRequest);
-
+ ExFreePool(CReply);
+
ObDereferenceObject(OurPort);
ObDereferenceObject(NamedPort);
-
+
return (STATUS_SUCCESS);
}
/**********************************************************************
* NAME EXPORTED
- * NtSecureConnectPort@36
- *
+ * NtSecureConnectPort/9
+ *
* DESCRIPTION
- * Connect to a named port and wait for the other side to
+ * Connect to a named port and wait for the other side to
* accept the connection. Possibly verify that the server
* matches the ServerSid (trusted server).
* Present in w2k+.
*
* ARGUMENTS
* ConnectedPort
- * PortName
+ * PortName: fully qualified name in the Ob name space;
* Qos
* WriteMap
* ServerSid
* MaxMessageSize
* ConnectInfo
* UserConnectInfoLength
- *
+ *
* RETURN VALUE
- *
*/
NTSTATUS STDCALL
NtSecureConnectPort (OUT PHANDLE ConnectedPort,
IN PUNICODE_STRING PortName,
IN PSECURITY_QUALITY_OF_SERVICE Qos,
- IN OUT PLPC_SECTION_WRITE WriteMap OPTIONAL,
+ IN OUT PPORT_VIEW WriteMap OPTIONAL,
IN PSID ServerSid OPTIONAL,
- IN OUT PLPC_SECTION_READ ReadMap OPTIONAL,
+ IN OUT PREMOTE_PORT_VIEW ReadMap OPTIONAL,
OUT PULONG MaxMessageSize OPTIONAL,
IN OUT PVOID ConnectInfo OPTIONAL,
IN OUT PULONG UserConnectInfoLength OPTIONAL)
{
- return (STATUS_NOT_IMPLEMENTED);
+ /* TODO: implement a new object type: WaitablePort */
+ /* TODO: verify the process' SID that hosts the rendez-vous port equals ServerSid */
+ return NtConnectPort (ConnectedPort,
+ PortName,
+ Qos,
+ WriteMap,
+ ReadMap,
+ MaxMessageSize,
+ ConnectInfo,
+ UserConnectInfoLength);
}
/* EOF */
projects / reactos.git / blobdiff