Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-15 08:56:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

- Use correct, documented, LPC Message structure (PORT_MESSAGE). Fix all caller code to use new member names and structure names.

Browse source 
svn path=/trunk/; revision=17275
This commit is contained in:
Alex Ionescu 2005-08-11 02:58:54 +00:00
parent eb742a2d70
commit 479fa4e4ae
30 changed files with 363 additions and 325 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

61
reactos/include/ndk/lpctypes.h
View file

@ -9,7 +9,7 @@
#ifndef _LPCTYPES_H #ifndef _LPCTYPES_H
#define _LPCTYPES_H #define _LPCTYPES_H
#define PORT_MESSAGE_TYPE(m) ((m).Header.MessageType) #define LPC_MESSAGE_TYPE(m) ((m).Header.u2.s2.Type)
/* DEPENDENCIES **************************************************************/ /* DEPENDENCIES **************************************************************/
@ -18,8 +18,8 @@
/* CONSTANTS *****************************************************************/ /* CONSTANTS *****************************************************************/
#define LPC_MESSAGE_BASE_SIZE 24 #define LPC_MESSAGE_BASE_SIZE 24
#define MAX_MESSAGE_DATA (0x130) #define MAX_MESSAGE_DATA (0x130)
#define PORT_MAX_DATA_LENGTH 0x104 #define LPC_MAX_DATA_LENGTH 0x104
#define PORT_MAX_MESSAGE_LENGTH 0x148 #define LPC_MAX_MESSAGE_LENGTH 0x148
/* ENUMERATIONS **************************************************************/ /* ENUMERATIONS **************************************************************/
@ -42,17 +42,50 @@ typedef enum _LPC_TYPE
/* TYPES *********************************************************************/ /* TYPES *********************************************************************/
/* FIXME: USE REAL DEFINITION */ #if defined(USE_LPC6432)
typedef struct _LPC_MESSAGE #define LPC_CLIENT_ID CLIENT_ID64
#define LPC_SIZE_T ULONGLONG
#define LPC_PVOID ULONGLONG
#define LPC_HANDLE ULONGLONG
#else
#define LPC_CLIENT_ID CLIENT_ID
#define LPC_SIZE_T SIZE_T
#define LPC_PVOID PVOID
#define LPC_HANDLE HANDLE
#endif
typedef struct _PORT_MESSAGE
{ {
USHORT DataSize; union
USHORT MessageSize; {
USHORT MessageType; struct
USHORT VirtualRangesOffset; {
CLIENT_ID ClientId; CSHORT DataLength;
ULONG MessageId; CSHORT TotalLength;
ULONG SectionSize; } s1;
} LPC_MESSAGE, *PLPC_MESSAGE; ULONG Length;
} u1;
union
{
struct
{
CSHORT Type;
CSHORT DataInfoOffset;
} s2;
ULONG ZeroInit;
} u2;
union
{
LPC_CLIENT_ID ClientId;
double DoNotUseThisField;
};
ULONG MessageId;
union
{
LPC_SIZE_T ClientViewSize;
ULONG CallbackId;
};
} PORT_MESSAGE, *PPORT_MESSAGE;
/* FIXME: USE REAL DEFINITION */ /* FIXME: USE REAL DEFINITION */
typedef struct _LPC_SECTION_WRITE typedef struct _LPC_SECTION_WRITE
@ -76,7 +109,7 @@ typedef struct _LPC_SECTION_READ
/* FIXME: USE REAL DEFINITION */ /* FIXME: USE REAL DEFINITION */
typedef struct _LPC_MAX_MESSAGE typedef struct _LPC_MAX_MESSAGE
{ {
LPC_MESSAGE Header; PORT_MESSAGE Header;
BYTE Data[MAX_MESSAGE_DATA]; BYTE Data[MAX_MESSAGE_DATA];
} LPC_MAX_MESSAGE, *PLPC_MAX_MESSAGE; } LPC_MAX_MESSAGE, *PLPC_MAX_MESSAGE;

46
reactos/include/ndk/zwfuncs.h
View file

@ -25,7 +25,7 @@ STDCALL
NtAcceptConnectPort( NtAcceptConnectPort(
PHANDLE PortHandle, PHANDLE PortHandle,
HANDLE NamedPortHandle, HANDLE NamedPortHandle,
PLPC_MESSAGE ServerReply, PPORT_MESSAGE ServerReply,
BOOLEAN AcceptIt, BOOLEAN AcceptIt,
PLPC_SECTION_WRITE WriteMap, PLPC_SECTION_WRITE WriteMap,
PLPC_SECTION_READ ReadMap PLPC_SECTION_READ ReadMap
@ -1243,14 +1243,14 @@ NTSTATUS
STDCALL STDCALL
NtImpersonateClientOfPort( NtImpersonateClientOfPort(
HANDLE PortHandle, HANDLE PortHandle,
PLPC_MESSAGE ClientMessage PPORT_MESSAGE ClientMessage
); );
NTSTATUS NTSTATUS
STDCALL STDCALL
ZwImpersonateClientOfPort( ZwImpersonateClientOfPort(
HANDLE PortHandle, HANDLE PortHandle,
PLPC_MESSAGE ClientMessage PPORT_MESSAGE ClientMessage
); );
NTSTATUS NTSTATUS
@ -1316,13 +1316,13 @@ ZwIsProcessInJob(
NTSTATUS NTSTATUS
STDCALL STDCALL
NtListenPort(HANDLE PortHandle, NtListenPort(HANDLE PortHandle,
PLPC_MESSAGE LpcMessage PPORT_MESSAGE LpcMessage
); );
NTSTATUS NTSTATUS
STDCALL STDCALL
ZwListenPort(HANDLE PortHandle, ZwListenPort(HANDLE PortHandle,
PLPC_MESSAGE LpcMessage PPORT_MESSAGE LpcMessage
); );
NTSTATUS NTSTATUS
@ -2825,7 +2825,7 @@ NTSTATUS
STDCALL STDCALL
NtReadRequestData( NtReadRequestData(
HANDLE PortHandle, HANDLE PortHandle,
PLPC_MESSAGE Message, PPORT_MESSAGE Message,
ULONG Index, ULONG Index,
PVOID Buffer, PVOID Buffer,
ULONG BufferLength, ULONG BufferLength,
@ -2836,7 +2836,7 @@ NTSTATUS
STDCALL STDCALL
ZwReadRequestData( ZwReadRequestData(
HANDLE PortHandle, HANDLE PortHandle,
PLPC_MESSAGE Message, PPORT_MESSAGE Message,
ULONG Index, ULONG Index,
PVOID Buffer, PVOID Buffer,
ULONG BufferLength, ULONG BufferLength,
@ -2944,14 +2944,14 @@ NTSTATUS
STDCALL STDCALL
NtReplyPort( NtReplyPort(
HANDLE PortHandle, HANDLE PortHandle,
PLPC_MESSAGE LpcReply PPORT_MESSAGE LpcReply
); );
NTSTATUS NTSTATUS
STDCALL STDCALL
ZwReplyPort( ZwReplyPort(
HANDLE PortHandle, HANDLE PortHandle,
PLPC_MESSAGE LpcReply PPORT_MESSAGE LpcReply
); );
NTSTATUS NTSTATUS
@ -2959,8 +2959,8 @@ STDCALL
NtReplyWaitReceivePort( NtReplyWaitReceivePort(
HANDLE PortHandle, HANDLE PortHandle,
PULONG PortId, PULONG PortId,
PLPC_MESSAGE MessageReply, PPORT_MESSAGE MessageReply,
PLPC_MESSAGE MessageRequest PPORT_MESSAGE MessageRequest
); );
NTSTATUS NTSTATUS
@ -2968,51 +2968,51 @@ STDCALL
ZwReplyWaitReceivePort( ZwReplyWaitReceivePort(
HANDLE PortHandle, HANDLE PortHandle,
PULONG PortId, PULONG PortId,
PLPC_MESSAGE MessageReply, PPORT_MESSAGE MessageReply,
PLPC_MESSAGE MessageRequest PPORT_MESSAGE MessageRequest
); );
NTSTATUS NTSTATUS
STDCALL STDCALL
NtReplyWaitReplyPort( NtReplyWaitReplyPort(
HANDLE PortHandle, HANDLE PortHandle,
PLPC_MESSAGE ReplyMessage PPORT_MESSAGE ReplyMessage
); );
NTSTATUS NTSTATUS
STDCALL STDCALL
ZwReplyWaitReplyPort( ZwReplyWaitReplyPort(
HANDLE PortHandle, HANDLE PortHandle,
PLPC_MESSAGE ReplyMessage PPORT_MESSAGE ReplyMessage
); );
NTSTATUS NTSTATUS
STDCALL STDCALL
NtRequestPort( NtRequestPort(
HANDLE PortHandle, HANDLE PortHandle,
PLPC_MESSAGE LpcMessage); PPORT_MESSAGE LpcMessage);
NTSTATUS NTSTATUS
STDCALL STDCALL
ZwRequestPort( ZwRequestPort(
HANDLE PortHandle, HANDLE PortHandle,
PLPC_MESSAGE LpcMessage PPORT_MESSAGE LpcMessage
); );
NTSTATUS NTSTATUS
STDCALL STDCALL
NtRequestWaitReplyPort( NtRequestWaitReplyPort(
HANDLE PortHandle, HANDLE PortHandle,
PLPC_MESSAGE LpcReply, PPORT_MESSAGE LpcReply,
PLPC_MESSAGE LpcRequest PPORT_MESSAGE LpcRequest
); );
NTSTATUS NTSTATUS
STDCALL STDCALL
ZwRequestWaitReplyPort( ZwRequestWaitReplyPort(
HANDLE PortHandle, HANDLE PortHandle,
PLPC_MESSAGE LpcReply, PPORT_MESSAGE LpcReply,
PLPC_MESSAGE LpcRequest PPORT_MESSAGE LpcRequest
); );
NTSTATUS NTSTATUS
@ -3975,7 +3975,7 @@ NTSTATUS
STDCALL STDCALL
NtWriteRequestData( NtWriteRequestData(
HANDLE PortHandle, HANDLE PortHandle,
PLPC_MESSAGE Message, PPORT_MESSAGE Message,
ULONG Index, ULONG Index,
PVOID Buffer, PVOID Buffer,
ULONG BufferLength, ULONG BufferLength,
@ -3986,7 +3986,7 @@ NTSTATUS
STDCALL STDCALL
ZwWriteRequestData( ZwWriteRequestData(
HANDLE PortHandle, HANDLE PortHandle,
PLPC_MESSAGE Message, PPORT_MESSAGE Message,
ULONG Index, ULONG Index,
PVOID Buffer, PVOID Buffer,
ULONG BufferLength, ULONG BufferLength,

2
reactos/include/subsys/csrss/csrss.h
View file

@ -491,7 +491,7 @@ typedef struct _CSR_API_MESSAGE
{ {
union union
{ {
LPC_MESSAGE Header; PORT_MESSAGE Header;
struct struct
{ {
BYTE HeaderReserved[LPC_MESSAGE_BASE_SIZE]; BYTE HeaderReserved[LPC_MESSAGE_BASE_SIZE];

4
reactos/include/subsys/lsass/lsass.h
View file

@ -96,7 +96,7 @@ typedef struct _LSASS_REGISTER_LOGON_PROCESS_REPLY
typedef union _LSASS_REQUEST typedef union _LSASS_REQUEST
{ {
LPC_MESSAGE Header; PORT_MESSAGE Header;
struct { struct {
UCHAR LpcHeader[LPC_MESSAGE_BASE_SIZE]; UCHAR LpcHeader[LPC_MESSAGE_BASE_SIZE];
ULONG Type; ULONG Type;
@ -115,7 +115,7 @@ typedef union _LSASS_REQUEST
typedef struct _LSASS_REPLY typedef struct _LSASS_REPLY
{ {
LPC_MESSAGE Header; PORT_MESSAGE Header;
NTSTATUS Status; NTSTATUS Status;
union union
{ {

4
reactos/include/subsys/sm/api.h
View file

@ -110,7 +110,7 @@ typedef struct _SM_PORT_MESSAGE_QRYINFO
typedef union _SM_PORT_MESSAGE typedef union _SM_PORT_MESSAGE
{ {
/*** LPC common header ***/ /*** LPC common header ***/
LPC_MESSAGE Header; PORT_MESSAGE Header;
struct { struct {
UCHAR LpcHeader[LPC_MESSAGE_BASE_SIZE]; UCHAR LpcHeader[LPC_MESSAGE_BASE_SIZE];
/*** SM common header ***/ /*** SM common header ***/
@ -138,7 +138,7 @@ typedef union _SM_PORT_MESSAGE
/*** MACRO ***********************************************************/ /*** MACRO ***********************************************************/
#define SM_CONNECT_DATA_SIZE(m) ((m).Header.DataSize-sizeof(USHORT)-sizeof(WORD)) #define SM_CONNECT_DATA_SIZE(m) ((m).Header.u1.s1.DataLength-sizeof(USHORT)-sizeof(WORD))
#define SM_PORT_DATA_SIZE(c) (sizeof(DWORD)+sizeof(NTSTATUS)+sizeof(c)) #define SM_PORT_DATA_SIZE(c) (sizeof(DWORD)+sizeof(NTSTATUS)+sizeof(c))
#define SM_PORT_MESSAGE_SIZE (sizeof(SM_PORT_MESSAGE)) #define SM_PORT_MESSAGE_SIZE (sizeof(SM_PORT_MESSAGE))

6
reactos/lib/lsasrv/lsaport.c
View file

@ -112,18 +112,18 @@ ProcessPortMessage(VOID)
DPRINT("Received message\n"); DPRINT("Received message\n");
if (Request.Header.MessageType == LPC_PORT_CLOSED) if (Request.Header.u2.s2.Type == LPC_PORT_CLOSED)
{ {
DPRINT("Port closed\n"); DPRINT("Port closed\n");
// return STATUS_UNSUCCESSFUL; // return STATUS_UNSUCCESSFUL;
} }
if (Request.Header.MessageType == LPC_REQUEST) if (Request.Header.u2.s2.Type == LPC_REQUEST)
{ {
DPRINT("Received request\n"); DPRINT("Received request\n");
} }
else if (Request.Header.MessageType == LPC_DATAGRAM) else if (Request.Header.u2.s2.Type == LPC_DATAGRAM)
{ {
DPRINT("Received datagram\n"); DPRINT("Received datagram\n");

10
reactos/lib/ntdll/csr/lpc.c
View file

@ -81,12 +81,12 @@ CsrClientCallServer(PCSR_API_MESSAGE Request,
/* Fill out the header */ /* Fill out the header */
Request->Type = ApiNumber; Request->Type = ApiNumber;
Request->Header.DataSize = RequestLength - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = RequestLength - LPC_MESSAGE_BASE_SIZE;
Request->Header.MessageSize = RequestLength; Request->Header.u1.s1.TotalLength = RequestLength;
DPRINT("CSR: API: %x, DataSize: %x, MessageSize: %x\n", DPRINT("CSR: API: %x, u1.s1.DataLength: %x, u1.s1.TotalLength: %x\n",
ApiNumber, ApiNumber,
Request->Header.DataSize, Request->Header.u1.s1.DataLength,
Request->Header.MessageSize); Request->Header.u1.s1.TotalLength);
/* Send the LPC Message */ /* Send the LPC Message */
Status = NtRequestWaitReplyPort(WindowsApiPort, Status = NtRequestWaitReplyPort(WindowsApiPort,

4
reactos/lib/ntdll/dbg/debug.c
View file

@ -24,7 +24,7 @@ static NTSTATUS (STDCALL * DbgSsCallback)(PVOID,PVOID) = NULL;
typedef struct _LPC_DBGSS_MESSAGE typedef struct _LPC_DBGSS_MESSAGE
{ {
LPC_MESSAGE Header; PORT_MESSAGE Header;
ULONG Unknown1; ULONG Unknown1;
ULONG Unknown2; ULONG Unknown2;
ULONG Unknown3; ULONG Unknown3;
@ -45,7 +45,7 @@ DbgSsServerThread(PVOID Unused)
Status = NtReplyWaitReceivePort (DbgSsApiPort, Status = NtReplyWaitReceivePort (DbgSsApiPort,
NULL, NULL,
NULL, NULL,
(PLPC_MESSAGE)&Message); (PPORT_MESSAGE)&Message);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
DbgPrint ("DbgSs: NtReplyWaitReceivePort failed - Status == %lx\n", DbgPrint ("DbgSs: NtReplyWaitReceivePort failed - Status == %lx\n",

22
reactos/lib/secur32/lsa.c
View file

@ -32,8 +32,8 @@ LsaDeregisterLogonProcess(HANDLE LsaHandle)
LSASS_REPLY Reply; LSASS_REPLY Reply;
NTSTATUS Status; NTSTATUS Status;
Request.Header.DataSize = 0; Request.Header.u1.s1.DataLength = 0;
Request.Header.MessageSize = sizeof(LSASS_REQUEST); Request.Header.u1.s1.TotalLength = sizeof(LSASS_REQUEST);
Request.Type = LSASS_REQUEST_DEREGISTER_LOGON_PROCESS; Request.Type = LSASS_REQUEST_DEREGISTER_LOGON_PROCESS;
Status = NtRequestWaitReplyPort(LsaHandle, Status = NtRequestWaitReplyPort(LsaHandle,
&Request.Header, &Request.Header,
@ -82,10 +82,10 @@ LsaCallAuthenticationPackage(HANDLE LsaHandle,
Request = (PLSASS_REQUEST)RawRequest; Request = (PLSASS_REQUEST)RawRequest;
Reply = (PLSASS_REPLY)RawReply; Reply = (PLSASS_REPLY)RawReply;
Request->Header.DataSize = sizeof(LSASS_REQUEST) + SubmitBufferLength - Request->Header.u1.s1.DataLength = sizeof(LSASS_REQUEST) + SubmitBufferLength -
LPC_MESSAGE_BASE_SIZE; LPC_MESSAGE_BASE_SIZE;
Request->Header.MessageSize = Request->Header.u1.s1.TotalLength =
Request->Header.DataSize + LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength + LPC_MESSAGE_BASE_SIZE;
Request->Type = LSASS_REQUEST_CALL_AUTHENTICATION_PACKAGE; Request->Type = LSASS_REQUEST_CALL_AUTHENTICATION_PACKAGE;
Request->d.CallAuthenticationPackageRequest.AuthenticationPackage = Request->d.CallAuthenticationPackageRequest.AuthenticationPackage =
AuthenticationPackage; AuthenticationPackage;
@ -145,9 +145,9 @@ LsaLookupAuthenticationPackage(HANDLE LsaHandle,
LSASS_REPLY Reply; LSASS_REPLY Reply;
Request = (PLSASS_REQUEST)RawRequest; Request = (PLSASS_REQUEST)RawRequest;
Request->Header.DataSize = sizeof(LSASS_REQUEST) + PackageName->Length - Request->Header.u1.s1.DataLength = sizeof(LSASS_REQUEST) + PackageName->Length -
LPC_MESSAGE_BASE_SIZE; LPC_MESSAGE_BASE_SIZE;
Request->Header.MessageSize = Request->Header.DataSize + Request->Header.u1.s1.TotalLength = Request->Header.u1.s1.DataLength +
LPC_MESSAGE_BASE_SIZE; LPC_MESSAGE_BASE_SIZE;
Request->Type = LSASS_REQUEST_LOOKUP_AUTHENTICATION_PACKAGE; Request->Type = LSASS_REQUEST_LOOKUP_AUTHENTICATION_PACKAGE;
@ -236,8 +236,8 @@ LsaLogonUser(HANDLE LsaHandle,
Request->d.LogonUserRequest.SourceContext = *SourceContext; Request->d.LogonUserRequest.SourceContext = *SourceContext;
Request->Type = LSASS_REQUEST_LOGON_USER; Request->Type = LSASS_REQUEST_LOGON_USER;
Request->Header.DataSize = RequestLength - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = RequestLength - LPC_MESSAGE_BASE_SIZE;
Request->Header.MessageSize = RequestLength + LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.TotalLength = RequestLength + LPC_MESSAGE_BASE_SIZE;
Reply = (PLSASS_REPLY)RawReply; Reply = (PLSASS_REPLY)RawReply;
@ -302,9 +302,9 @@ LsaRegisterLogonProcess(PLSA_STRING LsaLogonProcessName,
} }
Request.Type = LSASS_REQUEST_REGISTER_LOGON_PROCESS; Request.Type = LSASS_REQUEST_REGISTER_LOGON_PROCESS;
Request.Header.DataSize = sizeof(LSASS_REQUEST) - Request.Header.u1.s1.DataLength = sizeof(LSASS_REQUEST) -
LPC_MESSAGE_BASE_SIZE; LPC_MESSAGE_BASE_SIZE;
Request.Header.MessageSize = sizeof(LSASS_REQUEST); Request.Header.u1.s1.TotalLength = sizeof(LSASS_REQUEST);
Request.d.RegisterLogonProcessRequest.Length = LsaLogonProcessName->Length; Request.d.RegisterLogonProcessRequest.Length = LsaLogonProcessName->Length;
memcpy(Request.d.RegisterLogonProcessRequest.LogonProcessNameBuffer, memcpy(Request.d.RegisterLogonProcessRequest.LogonProcessNameBuffer,

8
reactos/lib/smdll/query.c
View file

@ -85,10 +85,10 @@ SmQueryInformation (IN HANDLE hSmApiPort,
SmReqMsg.SmHeader.ApiIndex = SM_API_QUERY_INFORMATION; SmReqMsg.SmHeader.ApiIndex = SM_API_QUERY_INFORMATION;
/* Prepare the port request message */ /* Prepare the port request message */
SmReqMsg.Header.MessageType = LPC_NEW_MESSAGE; SmReqMsg.Header.u2.s2.Type = LPC_NEW_MESSAGE;
SmReqMsg.Header.DataSize = SM_PORT_DATA_SIZE(SmReqMsg.Request); SmReqMsg.Header.u1.s1.DataLength = SM_PORT_DATA_SIZE(SmReqMsg.Request);
SmReqMsg.Header.MessageSize = SM_PORT_MESSAGE_SIZE; SmReqMsg.Header.u1.s1.TotalLength = SM_PORT_MESSAGE_SIZE;
Status = NtRequestWaitReplyPort (hSmApiPort, (PLPC_MESSAGE) & SmReqMsg, (PLPC_MESSAGE) & SmReqMsg); Status = NtRequestWaitReplyPort (hSmApiPort, (PPORT_MESSAGE) & SmReqMsg, (PPORT_MESSAGE) & SmReqMsg);
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
/* Unmarshal data */ /* Unmarshal data */

8
reactos/lib/smlib/compses.c
View file

@ -50,10 +50,10 @@ SmCompleteSession (IN HANDLE hSmApiPort,
SmReqMsg.SmHeader.ApiIndex = SM_API_COMPLETE_SESSION; SmReqMsg.SmHeader.ApiIndex = SM_API_COMPLETE_SESSION;
/* Port message */ /* Port message */
SmReqMsg.Header.MessageType = LPC_NEW_MESSAGE; SmReqMsg.Header.u2.s2.Type = LPC_NEW_MESSAGE;
SmReqMsg.Header.DataSize = SM_PORT_DATA_SIZE(SmReqMsg.Request); SmReqMsg.Header.u1.s1.DataLength = SM_PORT_DATA_SIZE(SmReqMsg.Request);
SmReqMsg.Header.MessageSize = SM_PORT_MESSAGE_SIZE; SmReqMsg.Header.u1.s1.TotalLength = SM_PORT_MESSAGE_SIZE;
Status = NtRequestWaitReplyPort (hSmApiPort, (PLPC_MESSAGE) & SmReqMsg, (PLPC_MESSAGE) & SmReqMsg); Status = NtRequestWaitReplyPort (hSmApiPort, (PPORT_MESSAGE) & SmReqMsg, (PPORT_MESSAGE) & SmReqMsg);
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
return SmReqMsg.SmHeader.Status; return SmReqMsg.SmHeader.Status;

24
reactos/lib/smlib/execpgm.c
View file

@ -60,23 +60,23 @@ SmExecuteProgram (IN HANDLE hSmApiPort,
SmReqMsg.SmHeader.ApiIndex = SM_API_EXECUTE_PROGRAMME; SmReqMsg.SmHeader.ApiIndex = SM_API_EXECUTE_PROGRAMME;
/* LPC message */ /* LPC message */
SmReqMsg.Header.MessageType = LPC_NEW_MESSAGE; SmReqMsg.Header.u2.s2.Type = LPC_NEW_MESSAGE;
SmReqMsg.Header.DataSize = SM_PORT_DATA_SIZE(SmReqMsg.Request); SmReqMsg.Header.u1.s1.DataLength = SM_PORT_DATA_SIZE(SmReqMsg.Request);
SmReqMsg.Header.MessageSize = SM_PORT_MESSAGE_SIZE; SmReqMsg.Header.u1.s1.TotalLength = SM_PORT_MESSAGE_SIZE;
DPRINT("SMLIB: %s:\n" DPRINT("SMLIB: %s:\n"
" MessageType = %d\n" " u2.s2.Type = %d\n"
" DataSize = %d\n" " u1.s1.DataLength = %d\n"
" MessageSize = %d\n" " u1.s1.TotalLength = %d\n"
" sizeof(LPC_MESSAGE)==%d\n", " sizeof(PORT_MESSAGE)==%d\n",
__FUNCTION__, __FUNCTION__,
SmReqMsg.Header.MessageType, SmReqMsg.Header.u2.s2.Type,
SmReqMsg.Header.DataSize, SmReqMsg.Header.u1.s1.DataLength,
SmReqMsg.Header.MessageSize, SmReqMsg.Header.u1.s1.TotalLength,
sizeof(LPC_MESSAGE)); sizeof(PORT_MESSAGE));
/* Call SM and wait for a reply */ /* Call SM and wait for a reply */
Status = NtRequestWaitReplyPort (hSmApiPort, (PLPC_MESSAGE) & SmReqMsg, (PLPC_MESSAGE) & SmReqMsg); Status = NtRequestWaitReplyPort (hSmApiPort, (PPORT_MESSAGE) & SmReqMsg, (PPORT_MESSAGE) & SmReqMsg);
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
return SmReqMsg.SmHeader.Status; return SmReqMsg.SmHeader.Status;

14
reactos/ntoskrnl/include/internal/port.h
View file

@ -31,7 +31,7 @@ typedef struct _EPORT
typedef struct _EPORT_CONNECT_REQUEST_MESSAGE typedef struct _EPORT_CONNECT_REQUEST_MESSAGE
{ {
LPC_MESSAGE MessageHeader; PORT_MESSAGE MessageHeader;
PEPROCESS ConnectingProcess; PEPROCESS ConnectingProcess;
struct _SECTION_OBJECT* SendSectionObject; struct _SECTION_OBJECT* SendSectionObject;
LARGE_INTEGER SendSectionOffset; LARGE_INTEGER SendSectionOffset;
@ -42,7 +42,7 @@ typedef struct _EPORT_CONNECT_REQUEST_MESSAGE
typedef struct _EPORT_CONNECT_REPLY_MESSAGE typedef struct _EPORT_CONNECT_REPLY_MESSAGE
{ {
LPC_MESSAGE MessageHeader; PORT_MESSAGE MessageHeader;
PVOID SendServerViewBase; PVOID SendServerViewBase;
ULONG ReceiveClientViewSize; ULONG ReceiveClientViewSize;
PVOID ReceiveClientViewBase; PVOID ReceiveClientViewBase;
@ -58,7 +58,7 @@ typedef struct _TERMINATION_PORT {
NTSTATUS STDCALL NTSTATUS STDCALL
LpcRequestPort (PEPORT Port, LpcRequestPort (PEPORT Port,
PLPC_MESSAGE LpcMessage); PPORT_MESSAGE LpcMessage);
NTSTATUS NTSTATUS
STDCALL STDCALL
LpcSendTerminationPort (PEPORT Port, LpcSendTerminationPort (PEPORT Port,
@ -87,13 +87,13 @@ typedef struct _QUEUEDMESSAGE
{ {
PEPORT Sender; PEPORT Sender;
LIST_ENTRY QueueListEntry; LIST_ENTRY QueueListEntry;
LPC_MESSAGE Message; PORT_MESSAGE Message;
UCHAR MessageData [MAX_MESSAGE_DATA]; UCHAR MessageData [MAX_MESSAGE_DATA];
} QUEUEDMESSAGE, *PQUEUEDMESSAGE; } QUEUEDMESSAGE, *PQUEUEDMESSAGE;
typedef struct _LPC_DBG_MESSAGE typedef struct _LPC_DBG_MESSAGE
{ {
LPC_MESSAGE Header; PORT_MESSAGE Header;
ULONG Type; ULONG Type;
ULONG Status; ULONG Status;
union union
@ -142,7 +142,7 @@ typedef struct _LPC_DBG_MESSAGE
typedef struct _LPC_TERMINATION_MESSAGE typedef struct _LPC_TERMINATION_MESSAGE
{ {
LPC_MESSAGE Header; PORT_MESSAGE Header;
LARGE_INTEGER CreationTime; LARGE_INTEGER CreationTime;
} LPC_TERMINATION_MESSAGE, *PLPC_TERMINATION_MESSAGE; } LPC_TERMINATION_MESSAGE, *PLPC_TERMINATION_MESSAGE;
@ -196,7 +196,7 @@ extern FAST_MUTEX LpcpLock;
NTSTATUS STDCALL NTSTATUS STDCALL
EiReplyOrRequestPort (IN PEPORT Port, EiReplyOrRequestPort (IN PEPORT Port,
IN PLPC_MESSAGE LpcReply, IN PPORT_MESSAGE LpcReply,
IN ULONG MessageType, IN ULONG MessageType,
IN PEPORT Sender); IN PEPORT Sender);

8
reactos/ntoskrnl/io/error.c
View file

@ -265,7 +265,7 @@ IopLogWorker (PVOID Parameter)
/* Initialize the log message */ /* Initialize the log message */
Message = (PIO_ERROR_LOG_MESSAGE)Request->Data; Message = (PIO_ERROR_LOG_MESSAGE)Request->Data;
Message->Type = 0xC; //IO_TYPE_ERROR_MESSAGE; Message->Type = IO_TYPE_ERROR_MESSAGE;
Message->Size = Message->Size =
sizeof(IO_ERROR_LOG_MESSAGE) - sizeof(IO_ERROR_LOG_PACKET) + sizeof(IO_ERROR_LOG_MESSAGE) - sizeof(IO_ERROR_LOG_PACKET) +
LogEntry->PacketSize + DriverNameLength; LogEntry->PacketSize + DriverNameLength;
@ -285,9 +285,9 @@ IopLogWorker (PVOID Parameter)
DPRINT ("SequenceNumber %lx\n", Packet->SequenceNumber); DPRINT ("SequenceNumber %lx\n", Packet->SequenceNumber);
Request->Header.DataSize = Message->Size; Request->Header.u1.s1.DataLength = Message->Size;
Request->Header.MessageSize = Request->Header.u1.s1.TotalLength =
Request->Header.DataSize + sizeof(LPC_MESSAGE); Request->Header.u1.s1.DataLength + sizeof(PPORT_MESSAGE);
/* Send the error message to the log port */ /* Send the error message to the log port */
Status = ZwRequestPort (IopLogPort, Status = ZwRequestPort (IopLogPort,

6
reactos/ntoskrnl/lpc/close.c
View file

@ -31,7 +31,7 @@ VOID STDCALL
LpcpClosePort (PVOID ObjectBody, ULONG HandleCount) LpcpClosePort (PVOID ObjectBody, ULONG HandleCount)
{ {
PEPORT Port = (PEPORT)ObjectBody; PEPORT Port = (PEPORT)ObjectBody;
LPC_MESSAGE Message; PORT_MESSAGE Message;
/* FIXME Race conditions here! */ /* FIXME Race conditions here! */
@ -44,8 +44,8 @@ LpcpClosePort (PVOID ObjectBody, ULONG HandleCount)
if (HandleCount == 1 && Port->State == EPORT_CONNECTED_CLIENT) if (HandleCount == 1 && Port->State == EPORT_CONNECTED_CLIENT)
{ {
DPRINT("Informing server\n"); DPRINT("Informing server\n");
Message.MessageSize = sizeof(LPC_MESSAGE); Message.u1.s1.TotalLength = sizeof(PORT_MESSAGE);
Message.DataSize = 0; Message.u1.s1.DataLength = 0;
EiReplyOrRequestPort (Port->OtherPort, EiReplyOrRequestPort (Port->OtherPort,
&Message, &Message,
LPC_PORT_CLOSED, LPC_PORT_CLOSED,

40
reactos/ntoskrnl/lpc/connect.c
View file

@ -90,14 +90,14 @@ EiConnectPort(IN PEPORT* ConnectedPort,
/* /*
* Initialize the request message. * Initialize the request message.
*/ */
RequestMessage->MessageHeader.DataSize = RequestMessage->MessageHeader.u1.s1.DataLength =
sizeof(EPORT_CONNECT_REQUEST_MESSAGE) + RequestConnectDataLength - sizeof(EPORT_CONNECT_REQUEST_MESSAGE) + RequestConnectDataLength -
sizeof(LPC_MESSAGE); sizeof(PORT_MESSAGE);
RequestMessage->MessageHeader.MessageSize = RequestMessage->MessageHeader.u1.s1.TotalLength =
sizeof(EPORT_CONNECT_REQUEST_MESSAGE) + RequestConnectDataLength; sizeof(EPORT_CONNECT_REQUEST_MESSAGE) + RequestConnectDataLength;
DPRINT("RequestMessageSize %d\n", DPRINT("RequestMessageSize %d\n",
RequestMessage->MessageHeader.MessageSize); RequestMessage->MessageHeader.u1.s1.TotalLength);
RequestMessage->MessageHeader.SectionSize = 0; RequestMessage->MessageHeader.ClientViewSize = 0;
RequestMessage->ConnectingProcess = PsGetCurrentProcess(); RequestMessage->ConnectingProcess = PsGetCurrentProcess();
ObReferenceObjectByPointer(RequestMessage->ConnectingProcess, ObReferenceObjectByPointer(RequestMessage->ConnectingProcess,
PROCESS_VM_OPERATION, PROCESS_VM_OPERATION,
@ -148,7 +148,7 @@ EiConnectPort(IN PEPORT* ConnectedPort,
/* /*
* Check for connection refusal. * Check for connection refusal.
*/ */
if (CReply->MessageHeader.MessageType == LPC_CONNECTION_REFUSED) if (CReply->MessageHeader.u2.s2.Type == LPC_CONNECTION_REFUSED)
{ {
ObDereferenceObject(OurPort); ObDereferenceObject(OurPort);
ExFreePool(Reply); ExFreePool(Reply);
@ -656,7 +656,7 @@ NtConnectPort (PHANDLE UnsafeConnectedPortHandle,
/*EXPORTED*/ NTSTATUS STDCALL /*EXPORTED*/ NTSTATUS STDCALL
NtAcceptConnectPort (PHANDLE ServerPortHandle, NtAcceptConnectPort (PHANDLE ServerPortHandle,
HANDLE NamedPortHandle, HANDLE NamedPortHandle,
PLPC_MESSAGE LpcMessage, PPORT_MESSAGE LpcMessage,
BOOLEAN AcceptIt, BOOLEAN AcceptIt,
PLPC_SECTION_WRITE WriteMap, PLPC_SECTION_WRITE WriteMap,
PLPC_SECTION_READ ReadMap) PLPC_SECTION_READ ReadMap)
@ -674,7 +674,7 @@ NtAcceptConnectPort (PHANDLE ServerPortHandle,
Size = sizeof(EPORT_CONNECT_REPLY_MESSAGE); Size = sizeof(EPORT_CONNECT_REPLY_MESSAGE);
if (LpcMessage) if (LpcMessage)
{ {
Size += LpcMessage->DataSize; Size += LpcMessage->u1.s1.DataLength;
} }
CReply = ExAllocatePool(NonPagedPool, Size); CReply = ExAllocatePool(NonPagedPool, Size);
@ -746,20 +746,20 @@ NtAcceptConnectPort (PHANDLE ServerPortHandle,
*/ */
if (LpcMessage != NULL) if (LpcMessage != NULL)
{ {
memcpy(&CReply->MessageHeader, LpcMessage, sizeof(LPC_MESSAGE)); memcpy(&CReply->MessageHeader, LpcMessage, sizeof(PORT_MESSAGE));
memcpy(&CReply->ConnectData, (PVOID)(LpcMessage + 1), memcpy(&CReply->ConnectData, (PVOID)(LpcMessage + 1),
LpcMessage->DataSize); LpcMessage->u1.s1.DataLength);
CReply->MessageHeader.MessageSize = CReply->MessageHeader.u1.s1.TotalLength =
sizeof(EPORT_CONNECT_REPLY_MESSAGE) + LpcMessage->DataSize; sizeof(EPORT_CONNECT_REPLY_MESSAGE) + LpcMessage->u1.s1.DataLength;
CReply->MessageHeader.DataSize = CReply->MessageHeader.MessageSize - CReply->MessageHeader.u1.s1.DataLength = CReply->MessageHeader.u1.s1.TotalLength -
sizeof(LPC_MESSAGE); sizeof(PORT_MESSAGE);
CReply->ConnectDataLength = LpcMessage->DataSize; CReply->ConnectDataLength = LpcMessage->u1.s1.DataLength;
} }
else else
{ {
CReply->MessageHeader.MessageSize = sizeof(EPORT_CONNECT_REPLY_MESSAGE); CReply->MessageHeader.u1.s1.TotalLength = sizeof(EPORT_CONNECT_REPLY_MESSAGE);
CReply->MessageHeader.DataSize = sizeof(EPORT_CONNECT_REPLY_MESSAGE) - CReply->MessageHeader.u1.s1.DataLength = sizeof(EPORT_CONNECT_REPLY_MESSAGE) -
sizeof(LPC_MESSAGE); sizeof(PORT_MESSAGE);
CReply->ConnectDataLength = 0; CReply->ConnectDataLength = 0;
} }
if (!AcceptIt) if (!AcceptIt)
@ -872,7 +872,7 @@ NtAcceptConnectPort (PHANDLE ServerPortHandle,
{ {
CReply->ReceiveClientViewBase = WriteMap->TargetViewBase; CReply->ReceiveClientViewBase = WriteMap->TargetViewBase;
} }
CReply->MaximumMessageSize = PORT_MAX_MESSAGE_LENGTH; CReply->MaximumMessageSize = LPC_MAX_MESSAGE_LENGTH;
/* /*
@ -881,7 +881,7 @@ NtAcceptConnectPort (PHANDLE ServerPortHandle,
OurPort->OtherPort = ConnectionRequest->Sender; OurPort->OtherPort = ConnectionRequest->Sender;
OurPort->OtherPort->OtherPort = OurPort; OurPort->OtherPort->OtherPort = OurPort;
EiReplyOrRequestPort(ConnectionRequest->Sender, EiReplyOrRequestPort(ConnectionRequest->Sender,
(PLPC_MESSAGE)CReply, (PPORT_MESSAGE)CReply,
LPC_REPLY, LPC_REPLY,
OurPort); OurPort);
ExFreePool(ConnectionRequest); ExFreePool(ConnectionRequest);

8
reactos/ntoskrnl/lpc/create.c
View file

@ -49,11 +49,11 @@ LpcpVerifyCreateParameters (IN PHANDLE PortHandle,
{ {
return (STATUS_INVALID_PORT_ATTRIBUTES); return (STATUS_INVALID_PORT_ATTRIBUTES);
} }
if (MaxConnectInfoLength > PORT_MAX_DATA_LENGTH) if (MaxConnectInfoLength > LPC_MAX_DATA_LENGTH)
{ {
return (STATUS_INVALID_PARAMETER_3); return (STATUS_INVALID_PARAMETER_3);
} }
if (MaxDataLength > PORT_MAX_MESSAGE_LENGTH) if (MaxDataLength > LPC_MAX_MESSAGE_LENGTH)
{ {
return (STATUS_INVALID_PARAMETER_4); return (STATUS_INVALID_PARAMETER_4);
} }
@ -128,8 +128,8 @@ NtCreatePort (PHANDLE PortHandle,
} }
Status = LpcpInitializePort (Port, EPORT_TYPE_SERVER_RQST_PORT, NULL); Status = LpcpInitializePort (Port, EPORT_TYPE_SERVER_RQST_PORT, NULL);
Port->MaxConnectInfoLength = PORT_MAX_DATA_LENGTH; Port->MaxConnectInfoLength = LPC_MAX_DATA_LENGTH;
Port->MaxDataLength = PORT_MAX_MESSAGE_LENGTH; Port->MaxDataLength = LPC_MAX_MESSAGE_LENGTH;
Port->MaxPoolUsage = MaxPoolUsage; Port->MaxPoolUsage = MaxPoolUsage;
ObDereferenceObject (Port); ObDereferenceObject (Port);

6
reactos/ntoskrnl/lpc/listen.c
View file

@ -40,7 +40,7 @@
*/ */
/*EXPORTED*/ NTSTATUS STDCALL /*EXPORTED*/ NTSTATUS STDCALL
NtListenPort (IN HANDLE PortHandle, NtListenPort (IN HANDLE PortHandle,
IN PLPC_MESSAGE ConnectMsg) IN PPORT_MESSAGE ConnectMsg)
{ {
NTSTATUS Status; NTSTATUS Status;
@ -58,12 +58,12 @@ NtListenPort (IN HANDLE PortHandle,
* Drop any other message. * Drop any other message.
*/ */
if (!NT_SUCCESS(Status) || if (!NT_SUCCESS(Status) ||
LPC_CONNECTION_REQUEST == ConnectMsg->MessageType) LPC_CONNECTION_REQUEST == ConnectMsg->u2.s2.Type)
{ {
DPRINT("Got message (type %x)\n", LPC_CONNECTION_REQUEST); DPRINT("Got message (type %x)\n", LPC_CONNECTION_REQUEST);
break; break;
} }
DPRINT("Got message (type %x)\n", ConnectMsg->MessageType); DPRINT("Got message (type %x)\n", ConnectMsg->u2.s2.Type);
} }
return (Status); return (Status);

2
reactos/ntoskrnl/lpc/port.c
View file

@ -121,7 +121,7 @@ LpcpInitializePort (IN OUT PEPORT Port,
*/ */
NTSTATUS STDCALL NTSTATUS STDCALL
NtImpersonateClientOfPort (HANDLE PortHandle, NtImpersonateClientOfPort (HANDLE PortHandle,
PLPC_MESSAGE ClientMessage) PPORT_MESSAGE ClientMessage)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
return(STATUS_NOT_IMPLEMENTED); return(STATUS_NOT_IMPLEMENTED);

2
reactos/ntoskrnl/lpc/receive.c
View file

@ -27,7 +27,7 @@
*/ */
NTSTATUS STDCALL NTSTATUS STDCALL
NtReadRequestData (HANDLE PortHandle, NtReadRequestData (HANDLE PortHandle,
PLPC_MESSAGE Message, PPORT_MESSAGE Message,
ULONG Index, ULONG Index,
PVOID Buffer, PVOID Buffer,
ULONG BufferLength, ULONG BufferLength,

46
reactos/ntoskrnl/lpc/reply.c
View file

@ -31,7 +31,7 @@
*/ */
NTSTATUS STDCALL NTSTATUS STDCALL
EiReplyOrRequestPort (IN PEPORT Port, EiReplyOrRequestPort (IN PEPORT Port,
IN PLPC_MESSAGE LpcReply, IN PPORT_MESSAGE LpcReply,
IN ULONG MessageType, IN ULONG MessageType,
IN PEPORT Sender) IN PEPORT Sender)
{ {
@ -49,12 +49,12 @@ EiReplyOrRequestPort (IN PEPORT Port,
if (LpcReply != NULL) if (LpcReply != NULL)
{ {
memcpy(&MessageReply->Message, LpcReply, LpcReply->MessageSize); memcpy(&MessageReply->Message, LpcReply, LpcReply->u1.s1.TotalLength);
} }
MessageReply->Message.ClientId.UniqueProcess = PsGetCurrentProcessId(); MessageReply->Message.ClientId.UniqueProcess = PsGetCurrentProcessId();
MessageReply->Message.ClientId.UniqueThread = PsGetCurrentThreadId(); MessageReply->Message.ClientId.UniqueThread = PsGetCurrentThreadId();
MessageReply->Message.MessageType = MessageType; MessageReply->Message.u2.s2.Type = MessageType;
MessageReply->Message.MessageId = InterlockedIncrementUL(&LpcpNextMessageId); MessageReply->Message.MessageId = InterlockedIncrementUL(&LpcpNextMessageId);
KeAcquireSpinLock(&Port->Lock, &oldIrql); KeAcquireSpinLock(&Port->Lock, &oldIrql);
@ -78,7 +78,7 @@ EiReplyOrRequestPort (IN PEPORT Port,
*/ */
NTSTATUS STDCALL NTSTATUS STDCALL
NtReplyPort (IN HANDLE PortHandle, NtReplyPort (IN HANDLE PortHandle,
IN PLPC_MESSAGE LpcReply) IN PPORT_MESSAGE LpcReply)
{ {
NTSTATUS Status; NTSTATUS Status;
PEPORT Port; PEPORT Port;
@ -137,8 +137,8 @@ NtReplyPort (IN HANDLE PortHandle,
NTSTATUS STDCALL NTSTATUS STDCALL
NtReplyWaitReceivePortEx(IN HANDLE PortHandle, NtReplyWaitReceivePortEx(IN HANDLE PortHandle,
OUT PULONG PortId, OUT PULONG PortId,
IN PLPC_MESSAGE LpcReply, IN PPORT_MESSAGE LpcReply,
OUT PLPC_MESSAGE LpcMessage, OUT PPORT_MESSAGE LpcMessage,
IN PLARGE_INTEGER Timeout) IN PLARGE_INTEGER Timeout)
{ {
PEPORT Port; PEPORT Port;
@ -159,7 +159,7 @@ NtReplyWaitReceivePortEx(IN HANDLE PortHandle,
_SEH_TRY _SEH_TRY
{ {
ProbeForWrite(LpcMessage, ProbeForWrite(LpcMessage,
sizeof(LPC_MESSAGE), sizeof(PORT_MESSAGE),
1); 1);
} }
_SEH_HANDLE _SEH_HANDLE
@ -252,15 +252,15 @@ NtReplyWaitReceivePortEx(IN HANDLE PortHandle,
Request = EiDequeueMessagePort(Port); Request = EiDequeueMessagePort(Port);
KeReleaseSpinLock(&Port->Lock, oldIrql); KeReleaseSpinLock(&Port->Lock, oldIrql);
if (Request->Message.MessageType == LPC_CONNECTION_REQUEST) if (Request->Message.u2.s2.Type == LPC_CONNECTION_REQUEST)
{ {
LPC_MESSAGE Header; PORT_MESSAGE Header;
PEPORT_CONNECT_REQUEST_MESSAGE CRequest; PEPORT_CONNECT_REQUEST_MESSAGE CRequest;
CRequest = (PEPORT_CONNECT_REQUEST_MESSAGE)&Request->Message; CRequest = (PEPORT_CONNECT_REQUEST_MESSAGE)&Request->Message;
memcpy(&Header, &Request->Message, sizeof(LPC_MESSAGE)); memcpy(&Header, &Request->Message, sizeof(PORT_MESSAGE));
Header.DataSize = CRequest->ConnectDataLength; Header.u1.s1.DataLength = CRequest->ConnectDataLength;
Header.MessageSize = Header.DataSize + sizeof(LPC_MESSAGE); Header.u1.s1.TotalLength = Header.u1.s1.DataLength + sizeof(PORT_MESSAGE);
if (PreviousMode != KernelMode) if (PreviousMode != KernelMode)
{ {
@ -272,7 +272,7 @@ NtReplyWaitReceivePortEx(IN HANDLE PortHandle,
RtlCopyMemory(LpcMessage, RtlCopyMemory(LpcMessage,
&Header, &Header,
sizeof(LPC_MESSAGE)); sizeof(PORT_MESSAGE));
RtlCopyMemory((PVOID)(LpcMessage + 1), RtlCopyMemory((PVOID)(LpcMessage + 1),
CRequest->ConnectData, CRequest->ConnectData,
CRequest->ConnectDataLength); CRequest->ConnectDataLength);
@ -287,7 +287,7 @@ NtReplyWaitReceivePortEx(IN HANDLE PortHandle,
{ {
RtlCopyMemory(LpcMessage, RtlCopyMemory(LpcMessage,
&Header, &Header,
sizeof(LPC_MESSAGE)); sizeof(PORT_MESSAGE));
RtlCopyMemory((PVOID)(LpcMessage + 1), RtlCopyMemory((PVOID)(LpcMessage + 1),
CRequest->ConnectData, CRequest->ConnectData,
CRequest->ConnectDataLength); CRequest->ConnectDataLength);
@ -300,12 +300,12 @@ NtReplyWaitReceivePortEx(IN HANDLE PortHandle,
_SEH_TRY _SEH_TRY
{ {
ProbeForWrite(LpcMessage, ProbeForWrite(LpcMessage,
Request->Message.MessageSize, Request->Message.u1.s1.TotalLength,
1); 1);
RtlCopyMemory(LpcMessage, RtlCopyMemory(LpcMessage,
&Request->Message, &Request->Message,
Request->Message.MessageSize); Request->Message.u1.s1.TotalLength);
} }
_SEH_HANDLE _SEH_HANDLE
{ {
@ -317,7 +317,7 @@ NtReplyWaitReceivePortEx(IN HANDLE PortHandle,
{ {
RtlCopyMemory(LpcMessage, RtlCopyMemory(LpcMessage,
&Request->Message, &Request->Message,
Request->Message.MessageSize); Request->Message.u1.s1.TotalLength);
} }
} }
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
@ -333,7 +333,7 @@ NtReplyWaitReceivePortEx(IN HANDLE PortHandle,
ObDereferenceObject(Port); ObDereferenceObject(Port);
return(Status); return(Status);
} }
if (Request->Message.MessageType == LPC_CONNECTION_REQUEST) if (Request->Message.u2.s2.Type == LPC_CONNECTION_REQUEST)
{ {
KeAcquireSpinLock(&Port->Lock, &oldIrql); KeAcquireSpinLock(&Port->Lock, &oldIrql);
EiEnqueueConnectMessagePort(Port, Request); EiEnqueueConnectMessagePort(Port, Request);
@ -372,8 +372,8 @@ NtReplyWaitReceivePortEx(IN HANDLE PortHandle,
NTSTATUS STDCALL NTSTATUS STDCALL
NtReplyWaitReceivePort (IN HANDLE PortHandle, NtReplyWaitReceivePort (IN HANDLE PortHandle,
OUT PULONG PortId, OUT PULONG PortId,
IN PLPC_MESSAGE LpcReply, IN PPORT_MESSAGE LpcReply,
OUT PLPC_MESSAGE LpcMessage) OUT PPORT_MESSAGE LpcMessage)
{ {
return(NtReplyWaitReceivePortEx (PortHandle, return(NtReplyWaitReceivePortEx (PortHandle,
PortId, PortId,
@ -395,7 +395,7 @@ NtReplyWaitReceivePort (IN HANDLE PortHandle,
*/ */
NTSTATUS STDCALL NTSTATUS STDCALL
NtReplyWaitReplyPort (HANDLE PortHandle, NtReplyWaitReplyPort (HANDLE PortHandle,
PLPC_MESSAGE ReplyMessage) PPORT_MESSAGE ReplyMessage)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
return(STATUS_NOT_IMPLEMENTED); return(STATUS_NOT_IMPLEMENTED);
@ -408,8 +408,8 @@ NTSTATUS
STDCALL STDCALL
LpcRequestWaitReplyPort ( LpcRequestWaitReplyPort (
IN PEPORT Port, IN PEPORT Port,
IN PLPC_MESSAGE LpcMessageRequest, IN PPORT_MESSAGE LpcMessageRequest,
OUT PLPC_MESSAGE LpcMessageReply OUT PPORT_MESSAGE LpcMessageReply
) )
{ {
UNIMPLEMENTED; UNIMPLEMENTED;

54
reactos/ntoskrnl/lpc/send.c
View file

@ -36,7 +36,7 @@ LpcSendTerminationPort (IN PEPORT Port,
LPC_TERMINATION_MESSAGE Msg; LPC_TERMINATION_MESSAGE Msg;
#ifdef __USE_NT_LPC__ #ifdef __USE_NT_LPC__
Msg.Header.MessageType = LPC_NEW_MESSAGE; Msg.Header.u2.s2.Type = LPC_NEW_MESSAGE;
#endif #endif
Msg.CreationTime = CreationTime; Msg.CreationTime = CreationTime;
Status = LpcRequestPort (Port, &Msg.Header); Status = LpcRequestPort (Port, &Msg.Header);
@ -91,7 +91,7 @@ LpcSendDebugMessagePort (IN PEPORT Port,
KeAcquireSpinLock(&Port->Lock, &oldIrql); KeAcquireSpinLock(&Port->Lock, &oldIrql);
ReplyMessage = EiDequeueMessagePort(Port); ReplyMessage = EiDequeueMessagePort(Port);
KeReleaseSpinLock(&Port->Lock, oldIrql); KeReleaseSpinLock(&Port->Lock, oldIrql);
memcpy(Reply, &ReplyMessage->Message, ReplyMessage->Message.MessageSize); memcpy(Reply, &ReplyMessage->Message, ReplyMessage->Message.u1.s1.TotalLength);
ExFreePool(ReplyMessage); ExFreePool(ReplyMessage);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
@ -118,7 +118,7 @@ LpcSendDebugMessagePort (IN PEPORT Port,
* @implemented * @implemented
*/ */
NTSTATUS STDCALL LpcRequestPort (IN PEPORT Port, NTSTATUS STDCALL LpcRequestPort (IN PEPORT Port,
IN PLPC_MESSAGE LpcMessage) IN PPORT_MESSAGE LpcMessage)
{ {
NTSTATUS Status; NTSTATUS Status;
@ -126,15 +126,15 @@ NTSTATUS STDCALL LpcRequestPort (IN PEPORT Port,
#ifdef __USE_NT_LPC__ #ifdef __USE_NT_LPC__
/* Check the message's type */ /* Check the message's type */
if (LPC_NEW_MESSAGE == LpcMessage->MessageType) if (LPC_NEW_MESSAGE == LpcMessage->u2.s2.Type)
{ {
LpcMessage->MessageType = LPC_DATAGRAM; LpcMessage->u2.s2.Type = LPC_DATAGRAM;
} }
else if (LPC_DATAGRAM == LpcMessage->MessageType) else if (LPC_DATAGRAM == LpcMessage->u2.s2.Type)
{ {
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
else if (LpcMessage->MessageType > LPC_CLIENT_DIED) else if (LpcMessage->u2.s2.Type > LPC_CLIENT_DIED)
{ {
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
@ -170,7 +170,7 @@ NTSTATUS STDCALL LpcRequestPort (IN PEPORT Port,
* @implemented * @implemented
*/ */
NTSTATUS STDCALL NtRequestPort (IN HANDLE PortHandle, NTSTATUS STDCALL NtRequestPort (IN HANDLE PortHandle,
IN PLPC_MESSAGE LpcMessage) IN PPORT_MESSAGE LpcMessage)
{ {
NTSTATUS Status; NTSTATUS Status;
PEPORT Port; PEPORT Port;
@ -214,15 +214,15 @@ NTSTATUS STDCALL NtRequestPort (IN HANDLE PortHandle,
*/ */
NTSTATUS STDCALL NTSTATUS STDCALL
NtRequestWaitReplyPort (IN HANDLE PortHandle, NtRequestWaitReplyPort (IN HANDLE PortHandle,
PLPC_MESSAGE UnsafeLpcRequest, PPORT_MESSAGE UnsafeLpcRequest,
PLPC_MESSAGE UnsafeLpcReply) PPORT_MESSAGE UnsafeLpcReply)
{ {
PETHREAD CurrentThread; PETHREAD CurrentThread;
struct _KPROCESS *AttachedProcess; struct _KPROCESS *AttachedProcess;
PEPORT Port; PEPORT Port;
PQUEUEDMESSAGE Message; PQUEUEDMESSAGE Message;
KIRQL oldIrql; KIRQL oldIrql;
PLPC_MESSAGE LpcRequest; PPORT_MESSAGE LpcRequest;
USHORT LpcRequestMessageSize = 0, LpcRequestDataSize = 0; USHORT LpcRequestMessageSize = 0, LpcRequestDataSize = 0;
KPROCESSOR_MODE PreviousMode; KPROCESSOR_MODE PreviousMode;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
@ -234,12 +234,12 @@ NtRequestWaitReplyPort (IN HANDLE PortHandle,
_SEH_TRY _SEH_TRY
{ {
ProbeForRead(UnsafeLpcRequest, ProbeForRead(UnsafeLpcRequest,
sizeof(LPC_MESSAGE), sizeof(PORT_MESSAGE),
1); 1);
ProbeForWrite(UnsafeLpcReply, ProbeForWrite(UnsafeLpcReply,
sizeof(LPC_MESSAGE), sizeof(PORT_MESSAGE),
1); 1);
LpcRequestMessageSize = UnsafeLpcRequest->MessageSize; LpcRequestMessageSize = UnsafeLpcRequest->u1.s1.TotalLength;
} }
_SEH_HANDLE _SEH_HANDLE
{ {
@ -254,7 +254,7 @@ NtRequestWaitReplyPort (IN HANDLE PortHandle,
} }
else else
{ {
LpcRequestMessageSize = UnsafeLpcRequest->MessageSize; LpcRequestMessageSize = UnsafeLpcRequest->u1.s1.TotalLength;
} }
DPRINT("NtRequestWaitReplyPort(PortHandle %x, LpcRequest %x, " DPRINT("NtRequestWaitReplyPort(PortHandle %x, LpcRequest %x, "
@ -292,7 +292,7 @@ NtRequestWaitReplyPort (IN HANDLE PortHandle,
KeDetachProcess(); KeDetachProcess();
} }
if (LpcRequestMessageSize > (sizeof(LPC_MESSAGE) + MAX_MESSAGE_DATA)) if (LpcRequestMessageSize > (sizeof(PORT_MESSAGE) + MAX_MESSAGE_DATA))
{ {
if (NULL != AttachedProcess) if (NULL != AttachedProcess)
{ {
@ -318,8 +318,8 @@ NtRequestWaitReplyPort (IN HANDLE PortHandle,
RtlCopyMemory(LpcRequest, RtlCopyMemory(LpcRequest,
UnsafeLpcRequest, UnsafeLpcRequest,
LpcRequestMessageSize); LpcRequestMessageSize);
LpcRequestMessageSize = LpcRequest->MessageSize; LpcRequestMessageSize = LpcRequest->u1.s1.TotalLength;
LpcRequestDataSize = LpcRequest->DataSize; LpcRequestDataSize = LpcRequest->u1.s1.DataLength;
} }
_SEH_HANDLE _SEH_HANDLE
{ {
@ -343,11 +343,11 @@ NtRequestWaitReplyPort (IN HANDLE PortHandle,
RtlCopyMemory(LpcRequest, RtlCopyMemory(LpcRequest,
UnsafeLpcRequest, UnsafeLpcRequest,
LpcRequestMessageSize); LpcRequestMessageSize);
LpcRequestMessageSize = LpcRequest->MessageSize; LpcRequestMessageSize = LpcRequest->u1.s1.TotalLength;
LpcRequestDataSize = LpcRequest->DataSize; LpcRequestDataSize = LpcRequest->u1.s1.DataLength;
} }
if (LpcRequestMessageSize > (sizeof(LPC_MESSAGE) + MAX_MESSAGE_DATA)) if (LpcRequestMessageSize > (sizeof(PORT_MESSAGE) + MAX_MESSAGE_DATA))
{ {
ExFreePool(LpcRequest); ExFreePool(LpcRequest);
if (NULL != AttachedProcess) if (NULL != AttachedProcess)
@ -357,7 +357,7 @@ NtRequestWaitReplyPort (IN HANDLE PortHandle,
ObDereferenceObject(Port); ObDereferenceObject(Port);
return(STATUS_PORT_MESSAGE_TOO_LONG); return(STATUS_PORT_MESSAGE_TOO_LONG);
} }
if (LpcRequestDataSize != (LpcRequestMessageSize - sizeof(LPC_MESSAGE))) if (LpcRequestDataSize != (LpcRequestMessageSize - sizeof(PORT_MESSAGE)))
{ {
ExFreePool(LpcRequest); ExFreePool(LpcRequest);
if (NULL != AttachedProcess) if (NULL != AttachedProcess)
@ -406,15 +406,15 @@ NtRequestWaitReplyPort (IN HANDLE PortHandle,
KeReleaseSpinLock(&Port->Lock, oldIrql); KeReleaseSpinLock(&Port->Lock, oldIrql);
if (Message) if (Message)
{ {
DPRINT("Message->Message.MessageSize %d\n", DPRINT("Message->Message.u1.s1.TotalLength %d\n",
Message->Message.MessageSize); Message->Message.u1.s1.TotalLength);
if (PreviousMode != KernelMode) if (PreviousMode != KernelMode)
{ {
_SEH_TRY _SEH_TRY
{ {
RtlCopyMemory(UnsafeLpcReply, RtlCopyMemory(UnsafeLpcReply,
&Message->Message, &Message->Message,
Message->Message.MessageSize); Message->Message.u1.s1.TotalLength);
} }
_SEH_HANDLE _SEH_HANDLE
{ {
@ -426,7 +426,7 @@ NtRequestWaitReplyPort (IN HANDLE PortHandle,
{ {
RtlCopyMemory(UnsafeLpcReply, RtlCopyMemory(UnsafeLpcReply,
&Message->Message, &Message->Message,
Message->Message.MessageSize); Message->Message.u1.s1.TotalLength);
} }
ExFreePool(Message); ExFreePool(Message);
} }
@ -463,7 +463,7 @@ NtRequestWaitReplyPort (IN HANDLE PortHandle,
* REVISIONS * REVISIONS
*/ */
NTSTATUS STDCALL NtWriteRequestData (HANDLE PortHandle, NTSTATUS STDCALL NtWriteRequestData (HANDLE PortHandle,
PLPC_MESSAGE Message, PPORT_MESSAGE Message,
ULONG Index, ULONG Index,
PVOID Buffer, PVOID Buffer,
ULONG BufferLength, ULONG BufferLength,

44
reactos/subsys/csrss/api/process.c
View file

@ -194,8 +194,8 @@ CSR_API(CsrCreateProcess)
PCSRSS_PROCESS_DATA NewProcessData; PCSRSS_PROCESS_DATA NewProcessData;
NTSTATUS Status; NTSTATUS Status;
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
NewProcessData = CsrCreateProcessData(Request->Data.CreateProcessRequest.NewProcessId); NewProcessData = CsrCreateProcessData(Request->Data.CreateProcessRequest.NewProcessId);
if (NewProcessData == NULL) if (NewProcessData == NULL)
@ -224,8 +224,8 @@ CSR_API(CsrCreateProcess)
CSR_API(CsrTerminateProcess) CSR_API(CsrTerminateProcess)
{ {
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Request->Header.DataSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE);
if (ProcessData == NULL) if (ProcessData == NULL)
{ {
@ -238,8 +238,8 @@ CSR_API(CsrTerminateProcess)
CSR_API(CsrConnectProcess) CSR_API(CsrConnectProcess)
{ {
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Request->Status = STATUS_SUCCESS; Request->Status = STATUS_SUCCESS;
@ -248,8 +248,8 @@ CSR_API(CsrConnectProcess)
CSR_API(CsrGetShutdownParameters) CSR_API(CsrGetShutdownParameters)
{ {
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (ProcessData == NULL) if (ProcessData == NULL)
{ {
@ -266,8 +266,8 @@ CSR_API(CsrGetShutdownParameters)
CSR_API(CsrSetShutdownParameters) CSR_API(CsrSetShutdownParameters)
{ {
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (ProcessData == NULL) if (ProcessData == NULL)
{ {
@ -284,8 +284,8 @@ CSR_API(CsrSetShutdownParameters)
CSR_API(CsrGetInputHandle) CSR_API(CsrGetInputHandle)
{ {
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (ProcessData == NULL) if (ProcessData == NULL)
{ {
@ -309,8 +309,8 @@ CSR_API(CsrGetInputHandle)
CSR_API(CsrGetOutputHandle) CSR_API(CsrGetOutputHandle)
{ {
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (ProcessData == NULL) if (ProcessData == NULL)
{ {
@ -336,8 +336,8 @@ CSR_API(CsrGetOutputHandle)
CSR_API(CsrCloseHandle) CSR_API(CsrCloseHandle)
{ {
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (ProcessData == NULL) if (ProcessData == NULL)
{ {
@ -352,8 +352,8 @@ CSR_API(CsrCloseHandle)
CSR_API(CsrVerifyHandle) CSR_API(CsrVerifyHandle)
{ {
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Request->Status = CsrVerifyObject(ProcessData, Request->Data.VerifyHandleRequest.Handle); Request->Status = CsrVerifyObject(ProcessData, Request->Data.VerifyHandleRequest.Handle);
if (!NT_SUCCESS(Request->Status)) if (!NT_SUCCESS(Request->Status))
@ -368,8 +368,8 @@ CSR_API(CsrDuplicateHandle)
{ {
Object_t *Object; Object_t *Object;
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
ProcessData = CsrGetProcessData(Request->Data.DuplicateHandleRequest.ProcessId); ProcessData = CsrGetProcessData(Request->Data.DuplicateHandleRequest.ProcessId);
Request->Status = CsrGetObject(ProcessData, Request->Data.DuplicateHandleRequest.Handle, &Object); Request->Status = CsrGetObject(ProcessData, Request->Data.DuplicateHandleRequest.Handle, &Object);
@ -388,8 +388,8 @@ CSR_API(CsrDuplicateHandle)
CSR_API(CsrGetInputWaitHandle) CSR_API(CsrGetInputWaitHandle)
{ {
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (ProcessData == NULL) if (ProcessData == NULL)
{ {

4
reactos/subsys/csrss/api/user.c
View file

@ -26,8 +26,8 @@ CSR_API(CsrRegisterServicesProcess)
{ {
NTSTATUS Status; NTSTATUS Status;
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (ServicesProcessIdValid == TRUE) if (ServicesProcessIdValid == TRUE)
{ {

21
reactos/subsys/csrss/api/wapi.c
View file

@ -79,11 +79,11 @@ CsrApiCallHandler(PCSRSS_PROCESS_DATA ProcessData,
{ {
if (ApiDefinitions[DefIndex].Type == Type) if (ApiDefinitions[DefIndex].Type == Type)
{ {
if (Request->Header.DataSize < ApiDefinitions[DefIndex].MinRequestSize) if (Request->Header.u1.s1.DataLength < ApiDefinitions[DefIndex].MinRequestSize)
{ {
DPRINT1("Request type %d min request size %d actual %d\n", DPRINT1("Request type %d min request size %d actual %d\n",
Type, ApiDefinitions[DefIndex].MinRequestSize, Type, ApiDefinitions[DefIndex].MinRequestSize,
Request->Header.DataSize); Request->Header.u1.s1.DataLength);
Request->Status = STATUS_INVALID_PARAMETER; Request->Status = STATUS_INVALID_PARAMETER;
} }
else else
@ -96,8 +96,8 @@ CsrApiCallHandler(PCSRSS_PROCESS_DATA ProcessData,
if (! Found) if (! Found)
{ {
DPRINT1("CSR: Unknown request type 0x%x\n", Request->Type); DPRINT1("CSR: Unknown request type 0x%x\n", Request->Type);
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Request->Status = STATUS_INVALID_SYSTEM_SERVICE; Request->Status = STATUS_INVALID_SYSTEM_SERVICE;
} }
} }
@ -133,7 +133,7 @@ ClientConnectionThread(HANDLE ServerPort)
} }
/* If the connection was closed, handle that */ /* If the connection was closed, handle that */
if (LpcRequest.Header.MessageType == LPC_PORT_CLOSED) if (LpcRequest.Header.u2.s2.Type == LPC_PORT_CLOSED)
{ {
CsrFreeProcessData( LpcRequest.Header.ClientId.UniqueProcess ); CsrFreeProcessData( LpcRequest.Header.ClientId.UniqueProcess );
break; break;
@ -151,7 +151,7 @@ ClientConnectionThread(HANDLE ServerPort)
if (ProcessData == NULL) if (ProcessData == NULL)
{ {
DPRINT1("CSR: Message %d: Unable to find data for process 0x%x\n", DPRINT1("CSR: Message %d: Unable to find data for process 0x%x\n",
LpcRequest.Header.MessageType, LpcRequest.Header.u2.s2.Type,
LpcRequest.Header.ClientId.UniqueProcess); LpcRequest.Header.ClientId.UniqueProcess);
break; break;
} }
@ -273,12 +273,13 @@ ServerSbApiPortThread (PVOID PortHandle)
{ {
HANDLE hSbApiPortListen = * (PHANDLE) PortHandle; HANDLE hSbApiPortListen = * (PHANDLE) PortHandle;
HANDLE hConnectedPort = (HANDLE) 0; HANDLE hConnectedPort = (HANDLE) 0;
LPC_MAX_MESSAGE Request = {{0}}; LPC_MAX_MESSAGE Request;
PVOID Context = NULL; PVOID Context = NULL;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
DPRINT("CSR: %s called\n", __FUNCTION__); DPRINT("CSR: %s called\n", __FUNCTION__);
RtlZeroMemory(&Request, sizeof(LPC_MAX_MESSAGE));
Status = NtListenPort (hSbApiPortListen, & Request.Header); Status = NtListenPort (hSbApiPortListen, & Request.Header);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
@ -305,7 +306,7 @@ DPRINT("-- 2\n");
__FUNCTION__, Status); __FUNCTION__, Status);
} else { } else {
DPRINT("-- 3\n"); DPRINT("-- 3\n");
PLPC_MESSAGE Reply = NULL; PPORT_MESSAGE Reply = NULL;
/* /*
* Tell the init thread the SM gave the * Tell the init thread the SM gave the
* green light for boostrapping. * green light for boostrapping.
@ -330,12 +331,12 @@ DPRINT("-- 4\n");
__FUNCTION__, Status); __FUNCTION__, Status);
break; break;
} }
switch (Request.Header.MessageType)//fix .h PORT_MESSAGE_TYPE(Request)) switch (Request.Header.u2.s2.Type)//fix .h PORT_MESSAGE_TYPE(Request))
{ {
/* TODO */ /* TODO */
default: default:
DPRINT1("CSR: %s received message (type=%d)\n", DPRINT1("CSR: %s received message (type=%d)\n",
__FUNCTION__, Request.Header.MessageType); __FUNCTION__, Request.Header.u2.s2.Type);
} }
DPRINT("-- 5\n"); DPRINT("-- 5\n");
} }

182
reactos/subsys/csrss/win32csr/conio.c
View file

@ -227,8 +227,8 @@ CSR_API(CsrAllocConsole)
DPRINT("CsrAllocConsole\n"); DPRINT("CsrAllocConsole\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (ProcessData == NULL) if (ProcessData == NULL)
{ {
@ -356,8 +356,8 @@ CSR_API(CsrFreeConsole)
DPRINT("CsrFreeConsole\n"); DPRINT("CsrFreeConsole\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (ProcessData == NULL || ProcessData->Console == NULL) if (ProcessData == NULL || ProcessData->Console == NULL)
{ {
@ -561,8 +561,8 @@ CSR_API(CsrReadConsole)
/* truncate length to CSRSS_MAX_READ_CONSOLE_REQUEST */ /* truncate length to CSRSS_MAX_READ_CONSOLE_REQUEST */
nNumberOfCharsToRead = min(Request->Data.ReadConsoleRequest.NrCharactersToRead, CSRSS_MAX_READ_CONSOLE / CharSize); nNumberOfCharsToRead = min(Request->Data.ReadConsoleRequest.NrCharactersToRead, CSRSS_MAX_READ_CONSOLE / CharSize);
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = Request->Header.MessageSize - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = Request->Header.u1.s1.TotalLength - LPC_MESSAGE_BASE_SIZE;
Buffer = Request->Data.ReadConsoleRequest.Buffer; Buffer = Request->Data.ReadConsoleRequest.Buffer;
UnicodeBuffer = (PWCHAR)Buffer; UnicodeBuffer = (PWCHAR)Buffer;
@ -670,7 +670,7 @@ CSR_API(CsrReadConsole)
{ {
Console->EchoCount = 0; /* if the client is no longer waiting on input, do not echo */ Console->EchoCount = 0; /* if the client is no longer waiting on input, do not echo */
} }
Request->Header.MessageSize += i * CharSize; Request->Header.u1.s1.TotalLength += i * CharSize;
ConioUnlockConsole(Console); ConioUnlockConsole(Console);
return Request->Status; return Request->Status;
@ -921,19 +921,19 @@ CSR_API(CsrWriteConsole)
DPRINT("CsrWriteConsole\n"); DPRINT("CsrWriteConsole\n");
if (Request->Header.DataSize if (Request->Header.u1.s1.DataLength
< sizeof(CSRSS_WRITE_CONSOLE) - 1 < sizeof(CSRSS_WRITE_CONSOLE) - 1
+ (Request->Data.WriteConsoleRequest.NrCharactersToWrite * CharSize)) + (Request->Data.WriteConsoleRequest.NrCharactersToWrite * CharSize))
{ {
DPRINT1("Invalid request size\n"); DPRINT1("Invalid request size\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
return Request->Status = STATUS_INVALID_PARAMETER; return Request->Status = STATUS_INVALID_PARAMETER;
} }
Status = ConioConsoleFromProcessData(ProcessData, &Console); Status = ConioConsoleFromProcessData(ProcessData, &Console);
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
{ {
@ -1430,8 +1430,8 @@ CSR_API(CsrGetScreenBufferInfo)
DPRINT("CsrGetScreenBufferInfo\n"); DPRINT("CsrGetScreenBufferInfo\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioLockScreenBuffer(ProcessData, Request->Data.ScreenBufferInfoRequest.ConsoleHandle, &Buff); Status = ConioLockScreenBuffer(ProcessData, Request->Data.ScreenBufferInfoRequest.ConsoleHandle, &Buff);
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
@ -1473,8 +1473,8 @@ CSR_API(CsrSetCursor)
return Request->Status = Status; return Request->Status = Status;
} }
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetCursorRequest.ConsoleHandle, &Buff); Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetCursorRequest.ConsoleHandle, &Buff);
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
@ -1556,19 +1556,19 @@ CSR_API(CsrWriteConsoleOutputChar)
CharSize = (Request->Data.WriteConsoleOutputCharRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR)); CharSize = (Request->Data.WriteConsoleOutputCharRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR));
if (Request->Header.DataSize if (Request->Header.u1.s1.DataLength
< sizeof(CSRSS_WRITE_CONSOLE_OUTPUT_CHAR) - 1 < sizeof(CSRSS_WRITE_CONSOLE_OUTPUT_CHAR) - 1
+ (Request->Data.WriteConsoleOutputCharRequest.Length * CharSize)) + (Request->Data.WriteConsoleOutputCharRequest.Length * CharSize))
{ {
DPRINT1("Invalid request size\n"); DPRINT1("Invalid request size\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
return Request->Status = STATUS_INVALID_PARAMETER; return Request->Status = STATUS_INVALID_PARAMETER;
} }
Status = ConioConsoleFromProcessData(ProcessData, &Console); Status = ConioConsoleFromProcessData(ProcessData, &Console);
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
if(Request->Data.WriteConsoleOutputCharRequest.Unicode) if(Request->Data.WriteConsoleOutputCharRequest.Unicode)
@ -1659,8 +1659,8 @@ CSR_API(CsrFillOutputChar)
DPRINT("CsrFillOutputChar\n"); DPRINT("CsrFillOutputChar\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioConsoleFromProcessData(ProcessData, &Console); Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
@ -1728,8 +1728,8 @@ CSR_API(CsrReadInputEvent)
DPRINT("CsrReadInputEvent\n"); DPRINT("CsrReadInputEvent\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Request->Data.ReadInputRequest.Event = ProcessData->ConsoleEvent; Request->Data.ReadInputRequest.Event = ProcessData->ConsoleEvent;
Status = ConioLockConsole(ProcessData, Request->Data.ReadInputRequest.ConsoleHandle, &Console); Status = ConioLockConsole(ProcessData, Request->Data.ReadInputRequest.ConsoleHandle, &Console);
@ -1808,19 +1808,19 @@ CSR_API(CsrWriteConsoleOutputAttrib)
DPRINT("CsrWriteConsoleOutputAttrib\n"); DPRINT("CsrWriteConsoleOutputAttrib\n");
if (Request->Header.DataSize if (Request->Header.u1.s1.DataLength
< sizeof(CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB) - 1 < sizeof(CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB) - 1
+ Request->Data.WriteConsoleOutputAttribRequest.Length) + Request->Data.WriteConsoleOutputAttribRequest.Length)
{ {
DPRINT1("Invalid request size\n"); DPRINT1("Invalid request size\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
return Request->Status = STATUS_INVALID_PARAMETER; return Request->Status = STATUS_INVALID_PARAMETER;
} }
Status = ConioConsoleFromProcessData(ProcessData, &Console); Status = ConioConsoleFromProcessData(ProcessData, &Console);
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
{ {
return Request->Status = Status; return Request->Status = Status;
@ -1896,8 +1896,8 @@ CSR_API(CsrFillOutputAttrib)
return Request->Status = Status; return Request->Status = Status;
} }
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioLockScreenBuffer(ProcessData, Request->Data.FillOutputAttribRequest.ConsoleHandle, &Buff); Status = ConioLockScreenBuffer(ProcessData, Request->Data.FillOutputAttribRequest.ConsoleHandle, &Buff);
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
{ {
@ -1952,8 +1952,8 @@ CSR_API(CsrGetCursorInfo)
DPRINT("CsrGetCursorInfo\n"); DPRINT("CsrGetCursorInfo\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioLockScreenBuffer(ProcessData, Request->Data.GetCursorInfoRequest.ConsoleHandle, &Buff); Status = ConioLockScreenBuffer(ProcessData, Request->Data.GetCursorInfoRequest.ConsoleHandle, &Buff);
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
@ -1976,8 +1976,8 @@ CSR_API(CsrSetCursorInfo)
DPRINT("CsrSetCursorInfo\n"); DPRINT("CsrSetCursorInfo\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioConsoleFromProcessData(ProcessData, &Console); Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
@ -2084,8 +2084,8 @@ CSR_API(CsrSetConsoleMode)
DPRINT("CsrSetConsoleMode\n"); DPRINT("CsrSetConsoleMode\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = Win32CsrGetObject(ProcessData, Status = Win32CsrGetObject(ProcessData,
Request->Data.SetConsoleModeRequest.ConsoleHandle, Request->Data.SetConsoleModeRequest.ConsoleHandle,
(Object_t **) &Console); (Object_t **) &Console);
@ -2121,8 +2121,8 @@ CSR_API(CsrGetConsoleMode)
DPRINT("CsrGetConsoleMode\n"); DPRINT("CsrGetConsoleMode\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = Win32CsrGetObject(ProcessData, Request->Data.GetConsoleModeRequest.ConsoleHandle, Status = Win32CsrGetObject(ProcessData, Request->Data.GetConsoleModeRequest.ConsoleHandle,
(Object_t **) &Console); (Object_t **) &Console);
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
@ -2170,8 +2170,8 @@ CSR_API(CsrCreateScreenBuffer)
return Request->Status = STATUS_INVALID_HANDLE; return Request->Status = STATUS_INVALID_HANDLE;
} }
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Buff = HeapAlloc(Win32CsrApiHeap, 0, sizeof(CSRSS_SCREEN_BUFFER)); Buff = HeapAlloc(Win32CsrApiHeap, 0, sizeof(CSRSS_SCREEN_BUFFER));
if (NULL == Buff) if (NULL == Buff)
@ -2213,8 +2213,8 @@ CSR_API(CsrSetScreenBuffer)
return Request->Status = STATUS_INVALID_HANDLE; return Request->Status = STATUS_INVALID_HANDLE;
} }
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetScreenBufferRequest.OutputHandle, &Buff); Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetScreenBufferRequest.OutputHandle, &Buff);
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
@ -2255,19 +2255,19 @@ CSR_API(CsrSetTitle)
DPRINT("CsrSetTitle\n"); DPRINT("CsrSetTitle\n");
if (Request->Header.DataSize if (Request->Header.u1.s1.DataLength
< sizeof(CSRSS_SET_TITLE) - 1 < sizeof(CSRSS_SET_TITLE) - 1
+ Request->Data.SetTitleRequest.Length) + Request->Data.SetTitleRequest.Length)
{ {
DPRINT1("Invalid request size\n"); DPRINT1("Invalid request size\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
return Request->Status = STATUS_INVALID_PARAMETER; return Request->Status = STATUS_INVALID_PARAMETER;
} }
Status = ConioLockConsole(ProcessData, Request->Data.SetTitleRequest.Console, &Console); Status = ConioLockConsole(ProcessData, Request->Data.SetTitleRequest.Console, &Console);
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if(! NT_SUCCESS(Status)) if(! NT_SUCCESS(Status))
{ {
Request->Status = Status; Request->Status = Status;
@ -2298,8 +2298,8 @@ CSR_API(CsrGetTitle)
DPRINT("CsrGetTitle\n"); DPRINT("CsrGetTitle\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioLockConsole(ProcessData, Status = ConioLockConsole(ProcessData,
Request->Data.GetTitleRequest.ConsoleHandle, Request->Data.GetTitleRequest.ConsoleHandle,
&Console); &Console);
@ -2314,8 +2314,8 @@ CSR_API(CsrGetTitle)
Request->Data.GetTitleRequest.ConsoleHandle = Request->Data.GetTitleRequest.ConsoleHandle; Request->Data.GetTitleRequest.ConsoleHandle = Request->Data.GetTitleRequest.ConsoleHandle;
Request->Data.GetTitleRequest.Length = Console->Title.Length; Request->Data.GetTitleRequest.Length = Console->Title.Length;
wcscpy (Request->Data.GetTitleRequest.Title, Console->Title.Buffer); wcscpy (Request->Data.GetTitleRequest.Title, Console->Title.Buffer);
Request->Header.MessageSize += Console->Title.Length; Request->Header.u1.s1.TotalLength += Console->Title.Length;
Request->Header.DataSize += Console->Title.Length; Request->Header.u1.s1.DataLength += Console->Title.Length;
Request->Status = STATUS_SUCCESS; Request->Status = STATUS_SUCCESS;
ConioUnlockConsole(Console); ConioUnlockConsole(Console);
@ -2346,8 +2346,8 @@ CSR_API(CsrWriteConsoleOutput)
return Request->Status = Status; return Request->Status = Status;
} }
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioLockScreenBuffer(ProcessData, Status = ConioLockScreenBuffer(ProcessData,
Request->Data.WriteConsoleOutputRequest.ConsoleHandle, Request->Data.WriteConsoleOutputRequest.ConsoleHandle,
&Buff); &Buff);
@ -2439,8 +2439,8 @@ CSR_API(CsrFlushInputBuffer)
DPRINT("CsrFlushInputBuffer\n"); DPRINT("CsrFlushInputBuffer\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioLockConsole(ProcessData, Status = ConioLockConsole(ProcessData,
Request->Data.FlushInputBufferRequest.ConsoleInput, Request->Data.FlushInputBufferRequest.ConsoleInput,
&Console); &Console);
@ -2491,8 +2491,8 @@ CSR_API(CsrScrollConsoleScreenBuffer)
return Request->Status = Status; return Request->Status = Status;
} }
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioLockScreenBuffer(ProcessData, ConsoleHandle, &Buff); Status = ConioLockScreenBuffer(ProcessData, ConsoleHandle, &Buff);
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
{ {
@ -2591,8 +2591,8 @@ CSR_API(CsrReadConsoleOutputChar)
DPRINT("CsrReadConsoleOutputChar\n"); DPRINT("CsrReadConsoleOutputChar\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = Request->Header.MessageSize - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = Request->Header.u1.s1.TotalLength - LPC_MESSAGE_BASE_SIZE;
ReadBuffer = Request->Data.ReadConsoleOutputCharRequest.String; ReadBuffer = Request->Data.ReadConsoleOutputCharRequest.String;
CharSize = (Request->Data.ReadConsoleOutputCharRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR)); CharSize = (Request->Data.ReadConsoleOutputCharRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR));
@ -2642,8 +2642,8 @@ CSR_API(CsrReadConsoleOutputChar)
Request->Status = STATUS_SUCCESS; Request->Status = STATUS_SUCCESS;
Request->Data.ReadConsoleOutputCharRequest.EndCoord.X = Xpos - Buff->ShowX; Request->Data.ReadConsoleOutputCharRequest.EndCoord.X = Xpos - Buff->ShowX;
Request->Data.ReadConsoleOutputCharRequest.EndCoord.Y = (Ypos - Buff->ShowY + Buff->MaxY) % Buff->MaxY; Request->Data.ReadConsoleOutputCharRequest.EndCoord.Y = (Ypos - Buff->ShowY + Buff->MaxY) % Buff->MaxY;
Request->Header.MessageSize += Request->Data.ReadConsoleOutputCharRequest.NumCharsToRead; Request->Header.u1.s1.TotalLength += Request->Data.ReadConsoleOutputCharRequest.NumCharsToRead;
Request->Header.DataSize += Request->Data.ReadConsoleOutputCharRequest.NumCharsToRead; Request->Header.u1.s1.DataLength += Request->Data.ReadConsoleOutputCharRequest.NumCharsToRead;
ConioUnlockScreenBuffer(Buff); ConioUnlockScreenBuffer(Buff);
if (NULL != Console) if (NULL != Console)
@ -2667,8 +2667,8 @@ CSR_API(CsrReadConsoleOutputAttrib)
DPRINT("CsrReadConsoleOutputAttrib\n"); DPRINT("CsrReadConsoleOutputAttrib\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = Request->Header.MessageSize - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = Request->Header.u1.s1.TotalLength - LPC_MESSAGE_BASE_SIZE;
ReadBuffer = Request->Data.ReadConsoleOutputAttribRequest.String; ReadBuffer = Request->Data.ReadConsoleOutputAttribRequest.String;
Status = ConioLockScreenBuffer(ProcessData, Request->Data.ReadConsoleOutputAttribRequest.ConsoleHandle, &Buff); Status = ConioLockScreenBuffer(ProcessData, Request->Data.ReadConsoleOutputAttribRequest.ConsoleHandle, &Buff);
@ -2704,8 +2704,8 @@ CSR_API(CsrReadConsoleOutputAttrib)
Request->Status = STATUS_SUCCESS; Request->Status = STATUS_SUCCESS;
Request->Data.ReadConsoleOutputAttribRequest.EndCoord.X = Xpos - Buff->ShowX; Request->Data.ReadConsoleOutputAttribRequest.EndCoord.X = Xpos - Buff->ShowX;
Request->Data.ReadConsoleOutputAttribRequest.EndCoord.Y = (Ypos - Buff->ShowY + Buff->MaxY) % Buff->MaxY; Request->Data.ReadConsoleOutputAttribRequest.EndCoord.Y = (Ypos - Buff->ShowY + Buff->MaxY) % Buff->MaxY;
Request->Header.MessageSize += Request->Data.ReadConsoleOutputAttribRequest.NumAttrsToRead; Request->Header.u1.s1.TotalLength += Request->Data.ReadConsoleOutputAttribRequest.NumAttrsToRead;
Request->Header.DataSize += Request->Data.ReadConsoleOutputAttribRequest.NumAttrsToRead; Request->Header.u1.s1.DataLength += Request->Data.ReadConsoleOutputAttribRequest.NumAttrsToRead;
ConioUnlockScreenBuffer(Buff); ConioUnlockScreenBuffer(Buff);
@ -2723,8 +2723,8 @@ CSR_API(CsrGetNumberOfConsoleInputEvents)
DPRINT("CsrGetNumberOfConsoleInputEvents\n"); DPRINT("CsrGetNumberOfConsoleInputEvents\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = Request->Header.MessageSize - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = Request->Header.u1.s1.TotalLength - LPC_MESSAGE_BASE_SIZE;
Status = ConioLockConsole(ProcessData, Request->Data.GetNumInputEventsRequest.ConsoleHandle, &Console); Status = ConioLockConsole(ProcessData, Request->Data.GetNumInputEventsRequest.ConsoleHandle, &Console);
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
@ -2768,8 +2768,8 @@ CSR_API(CsrPeekConsoleInput)
DPRINT("CsrPeekConsoleInput\n"); DPRINT("CsrPeekConsoleInput\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioLockConsole(ProcessData, Request->Data.GetNumInputEventsRequest.ConsoleHandle, &Console); Status = ConioLockConsole(ProcessData, Request->Data.GetNumInputEventsRequest.ConsoleHandle, &Console);
if(! NT_SUCCESS(Status)) if(! NT_SUCCESS(Status))
@ -2846,8 +2846,8 @@ CSR_API(CsrReadConsoleOutput)
DPRINT("CsrReadConsoleOutput\n"); DPRINT("CsrReadConsoleOutput\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioLockScreenBuffer(ProcessData, Request->Data.ReadConsoleOutputRequest.ConsoleHandle, &Buff); Status = ConioLockScreenBuffer(ProcessData, Request->Data.ReadConsoleOutputRequest.ConsoleHandle, &Buff);
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
@ -2935,8 +2935,8 @@ CSR_API(CsrWriteConsoleInput)
DPRINT("CsrWriteConsoleInput\n"); DPRINT("CsrWriteConsoleInput\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioLockConsole(ProcessData, Request->Data.WriteConsoleInputRequest.ConsoleHandle, &Console); Status = ConioLockConsole(ProcessData, Request->Data.WriteConsoleInputRequest.ConsoleHandle, &Console);
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
@ -3026,8 +3026,8 @@ CSR_API(CsrHardwareStateProperty)
DPRINT("CsrHardwareStateProperty\n"); DPRINT("CsrHardwareStateProperty\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioLockConsole(ProcessData, Status = ConioLockConsole(ProcessData,
Request->Data.ConsoleHardwareStateRequest.ConsoleHandle, Request->Data.ConsoleHardwareStateRequest.ConsoleHandle,
@ -3066,8 +3066,8 @@ CSR_API(CsrGetConsoleWindow)
DPRINT("CsrGetConsoleWindow\n"); DPRINT("CsrGetConsoleWindow\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioConsoleFromProcessData(ProcessData, &Console); Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
@ -3088,8 +3088,8 @@ CSR_API(CsrSetConsoleIcon)
DPRINT("CsrSetConsoleIcon\n"); DPRINT("CsrSetConsoleIcon\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Status = ConioConsoleFromProcessData(ProcessData, &Console); Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status)) if (! NT_SUCCESS(Status))
@ -3117,8 +3117,8 @@ CSR_API(CsrGetConsoleCodePage)
return Request->Status = Status; return Request->Status = Status;
} }
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Request->Data.GetConsoleCodePage.CodePage = Console->CodePage; Request->Data.GetConsoleCodePage.CodePage = Console->CodePage;
ConioUnlockConsole(Console); ConioUnlockConsole(Console);
return Request->Status = STATUS_SUCCESS; return Request->Status = STATUS_SUCCESS;
@ -3137,8 +3137,8 @@ CSR_API(CsrSetConsoleCodePage)
return Request->Status = Status; return Request->Status = Status;
} }
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (IsValidCodePage(Request->Data.SetConsoleCodePage.CodePage)) if (IsValidCodePage(Request->Data.SetConsoleCodePage.CodePage))
{ {
Console->CodePage = Request->Data.SetConsoleCodePage.CodePage; Console->CodePage = Request->Data.SetConsoleCodePage.CodePage;
@ -3162,8 +3162,8 @@ CSR_API(CsrGetConsoleOutputCodePage)
return Request->Status = Status; return Request->Status = Status;
} }
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
Request->Data.GetConsoleOutputCodePage.CodePage = Console->OutputCodePage; Request->Data.GetConsoleOutputCodePage.CodePage = Console->OutputCodePage;
ConioUnlockConsole(Console); ConioUnlockConsole(Console);
return Request->Status = STATUS_SUCCESS; return Request->Status = STATUS_SUCCESS;
@ -3182,8 +3182,8 @@ CSR_API(CsrSetConsoleOutputCodePage)
return Request->Status = Status; return Request->Status = Status;
} }
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (IsValidCodePage(Request->Data.SetConsoleOutputCodePage.CodePage)) if (IsValidCodePage(Request->Data.SetConsoleOutputCodePage.CodePage))
{ {
Console->OutputCodePage = Request->Data.SetConsoleOutputCodePage.CodePage; Console->OutputCodePage = Request->Data.SetConsoleOutputCodePage.CodePage;
@ -3206,8 +3206,8 @@ CSR_API(CsrGetProcessList)
DPRINT("CsrGetProcessList\n"); DPRINT("CsrGetProcessList\n");
Buffer = Request->Data.GetProcessListRequest.ProcessId; Buffer = Request->Data.GetProcessListRequest.ProcessId;
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = Request->Header.MessageSize - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = Request->Header.u1.s1.TotalLength - LPC_MESSAGE_BASE_SIZE;
nItems = nCopied = 0; nItems = nCopied = 0;
Request->Data.GetProcessListRequest.nProcessIdsCopied = 0; Request->Data.GetProcessListRequest.nProcessIdsCopied = 0;

12
reactos/subsys/csrss/win32csr/desktopbg.c
View file

@ -201,8 +201,8 @@ CSR_API(CsrCreateDesktop)
DPRINT("CsrCreateDesktop\n"); DPRINT("CsrCreateDesktop\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (! BgInitialized) if (! BgInitialized)
{ {
@ -251,8 +251,8 @@ CSR_API(CsrShowDesktop)
PRIVATE_NOTIFY_DESKTOP nmh; PRIVATE_NOTIFY_DESKTOP nmh;
DPRINT("CsrShowDesktop\n"); DPRINT("CsrShowDesktop\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
nmh.hdr.hwndFrom = Request->Data.ShowDesktopRequest.DesktopWindow; nmh.hdr.hwndFrom = Request->Data.ShowDesktopRequest.DesktopWindow;
nmh.hdr.idFrom = 0; nmh.hdr.idFrom = 0;
@ -275,8 +275,8 @@ CSR_API(CsrHideDesktop)
PRIVATE_NOTIFY_DESKTOP nmh; PRIVATE_NOTIFY_DESKTOP nmh;
DPRINT("CsrHideDesktop\n"); DPRINT("CsrHideDesktop\n");
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
nmh.hdr.hwndFrom = Request->Data.ShowDesktopRequest.DesktopWindow; nmh.hdr.hwndFrom = Request->Data.ShowDesktopRequest.DesktopWindow;
nmh.hdr.idFrom = 0; nmh.hdr.idFrom = 0;

12
reactos/subsys/csrss/win32csr/exitros.c
View file

@ -18,8 +18,8 @@ static HANDLE LogonProcess = NULL;
CSR_API(CsrRegisterLogonProcess) CSR_API(CsrRegisterLogonProcess)
{ {
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (Request->Data.RegisterLogonProcessRequest.Register) if (Request->Data.RegisterLogonProcessRequest.Register)
{ {
@ -51,8 +51,8 @@ CSR_API(CsrSetLogonNotifyWindow)
{ {
DWORD WindowCreator; DWORD WindowCreator;
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (0 == GetWindowThreadProcessId(Request->Data.SetLogonNotifyWindowRequest.LogonNotifyWindow, if (0 == GetWindowThreadProcessId(Request->Data.SetLogonNotifyWindowRequest.LogonNotifyWindow,
&WindowCreator)) &WindowCreator))
@ -77,8 +77,8 @@ CSR_API(CsrSetLogonNotifyWindow)
CSR_API(CsrExitReactos) CSR_API(CsrExitReactos)
{ {
Request->Header.MessageSize = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.DataSize = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE; Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - LPC_MESSAGE_BASE_SIZE;
if (NULL == LogonNotifyWindow) if (NULL == LogonNotifyWindow)
{ {

6
reactos/subsys/smss/debug.c
View file

@ -40,8 +40,9 @@ static VOID STDCALL
DbgSsApiPortThread (PVOID dummy) DbgSsApiPortThread (PVOID dummy)
{ {
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
LPC_MAX_MESSAGE Request = {{0}}; LPC_MAX_MESSAGE Request ;
RtlZeroMemory(&Request, sizeof(LPC_MAX_MESSAGE));
while (TRUE) while (TRUE)
{ {
Status = NtListenPort (DbgSsApiPort, & Request.Header); Status = NtListenPort (DbgSsApiPort, & Request.Header);
@ -59,8 +60,9 @@ static VOID STDCALL
DbgUiApiPortThread (PVOID dummy) DbgUiApiPortThread (PVOID dummy)
{ {
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
LPC_MAX_MESSAGE Request = {{0}}; LPC_MAX_MESSAGE Request;
RtlZeroMemory(&Request, sizeof(LPC_MAX_MESSAGE));
while (TRUE) while (TRUE)
{ {
Status = NtListenPort (DbgUiApiPort, & Request.Header); Status = NtListenPort (DbgUiApiPort, & Request.Header);

22
reactos/subsys/smss/smapi.c
View file

@ -108,11 +108,12 @@ SmpApiConnectedThread(PVOID pConnectedPort)
{ {
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
PVOID Unknown = NULL; PVOID Unknown = NULL;
PLPC_MESSAGE Reply = NULL; PPORT_MESSAGE Reply = NULL;
SM_PORT_MESSAGE Request = {{0}}; SM_PORT_MESSAGE Request;
HANDLE ConnectedPort = * (PHANDLE) pConnectedPort; HANDLE ConnectedPort = * (PHANDLE) pConnectedPort;
DPRINT("SM: %s called\n", __FUNCTION__); DPRINT("SM: %s called\n", __FUNCTION__);
RtlZeroMemory(&Request, sizeof(SM_PORT_MESSAGE));
while (TRUE) while (TRUE)
{ {
@ -121,14 +122,14 @@ SmpApiConnectedThread(PVOID pConnectedPort)
Status = NtReplyWaitReceivePort(ConnectedPort, Status = NtReplyWaitReceivePort(ConnectedPort,
(PULONG) & Unknown, (PULONG) & Unknown,
Reply, Reply,
(PLPC_MESSAGE) & Request); (PPORT_MESSAGE) & Request);
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
DPRINT("SM: %s: message received (type=%d)\n", DPRINT("SM: %s: message received (type=%d)\n",
__FUNCTION__, __FUNCTION__,
PORT_MESSAGE_TYPE(Request)); LPC_MESSAGE_TYPE(Request));
switch (Request.Header.MessageType) switch (Request.Header.u2.s2.Type)
{ {
case LPC_CONNECTION_REQUEST: case LPC_CONNECTION_REQUEST:
SmpHandleConnectionRequest (&Request); SmpHandleConnectionRequest (&Request);
@ -146,10 +147,10 @@ SmpApiConnectedThread(PVOID pConnectedPort)
(Request.SmHeader.ApiIndex < (sizeof SmApi / sizeof SmApi[0]))) (Request.SmHeader.ApiIndex < (sizeof SmApi / sizeof SmApi[0])))
{ {
Status = SmApi[Request.SmHeader.ApiIndex](&Request); Status = SmApi[Request.SmHeader.ApiIndex](&Request);
Reply = (PLPC_MESSAGE) & Request; Reply = (PPORT_MESSAGE) & Request;
} else { } else {
Request.SmHeader.Status = STATUS_NOT_IMPLEMENTED; Request.SmHeader.Status = STATUS_NOT_IMPLEMENTED;
Reply = (PLPC_MESSAGE) & Request; Reply = (PPORT_MESSAGE) & Request;
} }
} }
} else { } else {
@ -187,7 +188,7 @@ SmpHandleConnectionRequest (PSM_PORT_MESSAGE Request)
DPRINT("SM: %s called:\n SubSystemID=%d\n SbName=\"%S\"\n", DPRINT("SM: %s called:\n SubSystemID=%d\n SbName=\"%S\"\n",
__FUNCTION__, ConnectData->SubSystemId, ConnectData->SbName); __FUNCTION__, ConnectData->SubSystemId, ConnectData->SbName);
if(sizeof (SM_CONNECT_DATA) == Request->Header.DataSize) if(sizeof (SM_CONNECT_DATA) == Request->Header.u1.s1.DataLength)
{ {
if(IMAGE_SUBSYSTEM_UNKNOWN == ConnectData->SubSystemId) if(IMAGE_SUBSYSTEM_UNKNOWN == ConnectData->SubSystemId)
{ {
@ -248,7 +249,7 @@ SmpHandleConnectionRequest (PSM_PORT_MESSAGE Request)
#if defined(__USE_NT_LPC__) #if defined(__USE_NT_LPC__)
Status = NtAcceptConnectPort (ClientDataApiPort, Status = NtAcceptConnectPort (ClientDataApiPort,
Context, Context,
(PLPC_MESSAGE) Request, (PPORT_MESSAGE) Request,
Accept, Accept,
NULL, NULL,
NULL); NULL);
@ -317,9 +318,10 @@ VOID STDCALL
SmpApiThread (HANDLE ListeningPort) SmpApiThread (HANDLE ListeningPort)
{ {
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
LPC_MAX_MESSAGE Request = {{0}}; LPC_MAX_MESSAGE Request;
DPRINT("SM: %s called\n", __FUNCTION__); DPRINT("SM: %s called\n", __FUNCTION__);
RtlZeroMemory(&Request, sizeof(LPC_MAX_MESSAGE));
while (TRUE) while (TRUE)
{ {