-/* $Id: connect.c,v 1.12 2002/09/08 10:23:32 chorns Exp $
+/* $Id: connect.c,v 1.24 2004/02/01 18:19:28 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* INCLUDES *****************************************************************/
-#include <ddk/ntddk.h>
+#define NTOS_MODE_KERNEL
+#include <ntos.h>
#include <internal/ob.h>
#include <internal/port.h>
#include <internal/dbg.h>
/* 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,
- NULL,
+ Status = ObCreateObject (KernelMode,
ExPortType,
+ NULL,
+ KernelMode,
+ NULL,
+ sizeof(EPORT),
+ 0,
+ 0,
(PVOID*)&OurPort);
if (!NT_SUCCESS(Status))
{
*/
RequestMessage->MessageHeader.DataSize =
sizeof(EPORT_CONNECT_REQUEST_MESSAGE) + RequestConnectDataLength -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
RequestMessage->MessageHeader.MessageSize =
sizeof(EPORT_CONNECT_REQUEST_MESSAGE) + RequestConnectDataLength;
DPRINT("RequestMessageSize %d\n",
RequestMessage->MessageHeader.MessageSize);
- RequestMessage->MessageHeader.SharedSectionSize = 0;
+ RequestMessage->MessageHeader.SectionSize = 0;
RequestMessage->ConnectingProcess = PsGetCurrentProcess();
ObReferenceObjectByPointer(RequestMessage->ConnectingProcess,
PROCESS_VM_OPERATION,
/**********************************************************************
* NAME EXPORTED
- * NtConnectPort@32
+ * NtConnectPort/8
*
* DESCRIPTION
* Connect to a named port and wait for the other side to
- * accept the connection.
+ * accept or reject the connection request.
*
* ARGUMENTS
* ConnectedPort
*
* RETURN VALUE
*
+ * @unimplemented
*/
NTSTATUS STDCALL
NtConnectPort (PHANDLE UnsafeConnectedPortHandle,
*/
if (UnsafeWriteMap != NULL)
{
- Status = MmCopyFromCaller(&WriteMap, UnsafeWriteMap,
+ Status = MmCopyFromCaller(&WriteMap,
+ UnsafeWriteMap,
sizeof(LPC_SECTION_WRITE));
if (!NT_SUCCESS(Status))
{
}
Status = MmCopyFromCaller(ConnectData,
UnsafeConnectData,
- ConnectDataLength);
+ ConnectDataLength);
if (!NT_SUCCESS(Status))
{
ExFreePool(ConnectData);
{
if (ExGetPreviousMode() != KernelMode)
{
- MmCopyToCaller(UnsafeConnectData, ConnectData,
+ MmCopyToCaller(UnsafeConnectData,
+ ConnectData,
ConnectDataLength);
ExFreePool(ConnectData);
}
- MmCopyToCaller(UnsafeConnectDataLength, &ConnectDataLength,
+ MmCopyToCaller(UnsafeConnectDataLength,
+ &ConnectDataLength,
sizeof(ULONG));
}
return(Status);
{
if (ExGetPreviousMode() != KernelMode)
{
- Status = MmCopyToCaller(UnsafeConnectData, ConnectData,
+ Status = MmCopyToCaller(UnsafeConnectData,
+ ConnectData,
ConnectDataLength);
ExFreePool(ConnectData);
if (!NT_SUCCESS(Status))
return(Status);
}
}
- Status = MmCopyToCaller(UnsafeConnectDataLength, &ConnectDataLength,
+ Status = MmCopyToCaller(UnsafeConnectDataLength,
+ &ConnectDataLength,
sizeof(ULONG));
if (!NT_SUCCESS(Status))
{
{
return(Status);
}
- Status = MmCopyToCaller(UnsafeConnectedPortHandle, &ConnectedPortHandle,
+ Status = MmCopyToCaller(UnsafeConnectedPortHandle,
+ &ConnectedPortHandle,
sizeof(HANDLE));
if (!NT_SUCCESS(Status))
{
}
if (UnsafeWriteMap != NULL)
{
- Status = MmCopyToCaller(UnsafeWriteMap, &WriteMap,
+ Status = MmCopyToCaller(UnsafeWriteMap,
+ &WriteMap,
sizeof(LPC_SECTION_WRITE));
if (!NT_SUCCESS(Status))
{
}
if (UnsafeReadMap != NULL)
{
- Status = MmCopyToCaller(UnsafeReadMap, &ReadMap,
+ Status = MmCopyToCaller(UnsafeReadMap,
+ &ReadMap,
sizeof(LPC_SECTION_READ));
if (!NT_SUCCESS(Status))
{
}
if (UnsafeMaximumMessageSize != NULL)
{
- Status = MmCopyToCaller(UnsafeMaximumMessageSize,
+ Status = MmCopyToCaller(UnsafeMaximumMessageSize,
&MaximumMessageSize,
- sizeof(LPC_SECTION_WRITE));
+ sizeof(ULONG));
if (!NT_SUCCESS(Status))
{
return(Status);
/*
* 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,
KIRQL oldIrql;
PEPORT_CONNECT_REQUEST_MESSAGE CRequest;
PEPORT_CONNECT_REPLY_MESSAGE CReply;
+ ULONG Size;
+
+ Size = sizeof(EPORT_CONNECT_REPLY_MESSAGE);
+ if (LpcMessage)
+ {
+ Size += LpcMessage->DataSize;
+ }
- CReply = ExAllocatePool(NonPagedPool,
- sizeof(EPORT_CONNECT_REPLY_MESSAGE) + LpcMessage->DataSize);
+ CReply = ExAllocatePool(NonPagedPool, Size);
if (CReply == NULL)
{
return(STATUS_NO_MEMORY);
/*
* Create a port object for our side of the connection
*/
- if (AcceptIt == 1)
+ if (AcceptIt)
{
- Status = ObCreateObject(ServerPortHandle,
- PORT_ALL_ACCESS,
- NULL,
+ Status = ObCreateObject(ExGetPreviousMode(),
ExPortType,
+ NULL,
+ ExGetPreviousMode(),
+ NULL,
+ sizeof(EPORT),
+ 0,
+ 0,
(PVOID*)&OurPort);
if (!NT_SUCCESS(Status))
{
+ ExFreePool(CReply);
+ ObDereferenceObject(NamedPort);
+ return(Status);
+ }
+
+ Status = ObInsertObject ((PVOID)OurPort,
+ NULL,
+ PORT_ALL_ACCESS,
+ 0,
+ NULL,
+ ServerPortHandle);
+ if (!NT_SUCCESS(Status))
+ {
+ ObDereferenceObject(OurPort);
+ ExFreePool(CReply);
ObDereferenceObject(NamedPort);
return(Status);
}
+
NiInitializePort(OurPort);
}
-
+
/*
* Dequeue the connection request
*/
*/
if (LpcMessage != NULL)
{
- memcpy(&CReply->MessageHeader, LpcMessage, sizeof(LPC_MESSAGE_HEADER));
+ memcpy(&CReply->MessageHeader, LpcMessage, sizeof(LPC_MESSAGE));
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);
+ sizeof(LPC_MESSAGE);
CReply->ConnectDataLength = LpcMessage->DataSize;
}
else
{
CReply->MessageHeader.MessageSize = sizeof(EPORT_CONNECT_REPLY_MESSAGE);
CReply->MessageHeader.DataSize = sizeof(EPORT_CONNECT_REPLY_MESSAGE) -
- sizeof(LPC_MESSAGE_HEADER);
+ sizeof(LPC_MESSAGE);
CReply->ConnectDataLength = 0;
}
- if (AcceptIt != 1)
+ if (!AcceptIt)
{
EiReplyOrRequestPort(ConnectionRequest->Sender,
&CReply->MessageHeader,
{
CReply->ReceiveClientViewBase = WriteMap->TargetViewBase;
}
- CReply->MaximumMessageSize = 0x148;
+ CReply->MaximumMessageSize = PORT_MAX_MESSAGE_LENGTH;
/*
LPC_REPLY,
OurPort);
ExFreePool(ConnectionRequest);
+ ExFreePool(CReply);
ObDereferenceObject(OurPort);
ObDereferenceObject(NamedPort);
/**********************************************************************
* NAME EXPORTED
- * NtSecureConnectPort@36
+ * NtSecureConnectPort/9
*
* DESCRIPTION
* Connect to a named port and wait for the other side to
*
* ARGUMENTS
* ConnectedPort
- * PortName
+ * PortName: fully qualified name in the Ob name space;
* Qos
* WriteMap
* ServerSid
* UserConnectInfoLength
*
* RETURN VALUE
- *
*/
NTSTATUS STDCALL
NtSecureConnectPort (OUT PHANDLE ConnectedPort,
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