- Use the new messaging structures and the new macros, plus the new CSR_API function's signature (--> and rename some variables).
- Code cleaning & formatting.
[CSRSS/NDK]
- Reorganize all the header files in logical units (server.h for server-side of CSR, client.h for client-side, and msg.h for messaging), removing duplicated definitions.
- Code cleaning & formatting.
The next step would be to activate the code of server-dll loading inside csrsrv, then moving all the console-related APIs from win32csr to winsrv, the latter built with the same structure as csrsrv's.
svn path=/branches/ros-csrss/; revision=57570
PULONG PriorityClass)
{
NTSTATUS Status;
- CSR_API_MESSAGE2 ApiMessage; /* <- Remove the "2" when CSR is commited */
- PCSR_SET_PRIORITY_CLASS SetPriorityClass = &ApiMessage.SetPriorityClass;
+ CSR_API_MESSAGE ApiMessage;
+ PCSR_SET_PRIORITY_CLASS SetPriorityClass = &ApiMessage.Data.SetPriorityClass;
/* Set up the data for CSR */
DbgBreakPoint();
SetPriorityClass->PriorityClass = *PriorityClass;
/* Call it */
- Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
+ Status = CsrClientCallServer(&ApiMessage,
NULL,
- CSR_MAKE_OPCODE(CsrpSetPriorityClass,
- CSR_SRV_SERVER),
+ CSR_CREATE_API_NUMBER(CSR_SRV_SERVER, CsrpSetPriorityClass),
sizeof(CSR_SET_PRIORITY_CLASS));
/* Return what we got, if requested */
CsrIdentifyAlertableThread (VOID)
{
NTSTATUS Status;
- CSR_API_MESSAGE2 ApiMessage; /* <- Remove the "2" when CSR is commited */
+ CSR_API_MESSAGE ApiMessage;
PCSR_IDENTIFY_ALTERTABLE_THREAD IdentifyAlertableThread;
/* Set up the data for CSR */
DbgBreakPoint();
- IdentifyAlertableThread = &ApiMessage.IdentifyAlertableThread;
+ IdentifyAlertableThread = &ApiMessage.Data.IdentifyAlertableThread;
IdentifyAlertableThread->Cid = NtCurrentTeb()->ClientId;
/* Call it */
- Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
+ Status = CsrClientCallServer(&ApiMessage,
NULL,
- CSR_MAKE_OPCODE(CsrpIdentifyAlertable,
- CSR_SRV_SERVER),
+ CSR_CREATE_API_NUMBER(CSR_SRV_SERVER, CsrpIdentifyAlertable),
sizeof(CSR_SET_PRIORITY_CLASS));
/* Return to caller */
PCSR_SERVER_API_ROUTINE CsrServerApiRoutine;
#define UNICODE_PATH_SEP L"\\"
-#define CSR_PORT_NAME L"ApiPort"
/* FUNCTIONS *****************************************************************/
ApiMessage->Header.u1.s1.TotalLength = RequestLength;
/* Fill out the CSR Header */
- ApiMessage->Type = ApiNumber;
- //ApiMessage->Opcode = ApiNumber; <- Activate with new CSR
+ ApiMessage->ApiNumber = ApiNumber;
ApiMessage->CsrCaptureData = NULL;
DPRINT("API: %lx, u1.s1.DataLength: %x, u1.s1.TotalLength: %x\n",
HANDLE hCsrSrv;
ANSI_STRING CsrServerRoutineName;
PCSR_CAPTURE_BUFFER CaptureBuffer;
- CSR_API_MESSAGE RosApiMessage;
- CSR_API_MESSAGE2 ApiMessage;
- PCSR_CLIENT_CONNECT ClientConnect = &ApiMessage.ClientConnect;
+ CSR_API_MESSAGE ApiMessage;
+ PCSR_CLIENT_CONNECT ClientConnect = &ApiMessage.Data.CsrClientConnect;
/* Validate the Connection Info */
DPRINT("CsrClientConnectToServer: %lx %p\n", ServerId, ConnectionInfo);
#if 0
Status = CsrClientCallServer(&ApiMessage,
CaptureBuffer,
- CSR_MAKE_OPCODE(CsrpClientConnect,
- CSR_SRV_DLL),
+ CSR_CREATE_API_NUMBER(CSR_SRV_DLL, CsrpClientConnect),
sizeof(CSR_CLIENT_CONNECT));
-#endif
- Status = CsrClientCallServer(&RosApiMessage,
- NULL,
- MAKE_CSR_API(CONNECT_PROCESS, CSR_NATIVE),
+#else
+ Status = CsrClientCallServer(&ApiMessage,
+ CaptureBuffer,
+ CSR_CREATE_API_NUMBER(CSR_NATIVE, CONNECT_PROCESS),
sizeof(CSR_API_MESSAGE));
+#endif
}
else
{
#include "ntdllp.h"
/* CSRSS Header */
-#include <csrss/csrss.h>
+#include <csrss/client.h>
+#include <csrss/csrss.h> // FIXME: data header.
/* PSEH */
#include <pseh/pseh2.h>
/* FIXME: Cleanup this mess */
typedef NTSTATUS (NTAPI *PEPFUNC)(PPEB);
NTSTATUS LdrMapSections(HANDLE ProcessHandle,
- PVOID ImageBase,
- HANDLE SectionHandle,
- PIMAGE_NT_HEADERS NTHeaders);
+ PVOID ImageBase,
+ HANDLE SectionHandle,
+ PIMAGE_NT_HEADERS NTHeaders);
NTSTATUS LdrMapNTDllForProcess(HANDLE ProcessHandle,
- PHANDLE NTDllSectionHandle);
+ PHANDLE NTDllSectionHandle);
ULONG
LdrpGetResidentSize(PIMAGE_NT_HEADERS NTHeaders);
spec2def(kernel32.dll kernel32.spec ADD_IMPORTLIB)
list(APPEND SOURCE
- client/appcache.c
- client/atom.c
- client/compname.c
+ client/appcache.c
+ client/atom.c
+ client/compname.c
client/debugger.c
client/dosdev.c
- client/dllmain.c
- client/environ.c
+ client/dllmain.c
+ client/environ.c
client/except.c
client/fiber.c
- client/handle.c
+ client/handle.c
client/heapmem.c
client/job.c
- client/loader.c
- client/path.c
- client/perfcnt.c
- client/power.c
+ client/loader.c
+ client/path.c
+ client/perfcnt.c
+ client/power.c
client/proc.c
- client/resntfy.c
+ client/resntfy.c
client/session.c
client/synch.c
- client/sysinfo.c
- client/time.c
- client/timerqueue.c
- client/toolhelp.c
- client/utils.c
+ client/sysinfo.c
+ client/time.c
+ client/timerqueue.c
+ client/toolhelp.c
+ client/utils.c
client/thread.c
- client/vdm.c
- client/version.c
+ client/vdm.c
+ client/version.c
client/virtmem.c
client/vista.c
client/file/backup.c
BasepInitConsole(VOID)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
BOOLEAN NotConsole = FALSE;
PRTL_USER_PROCESS_PARAMETERS Parameters = NtCurrentPeb()->ProcessParameters;
* console message to the Base Server. When we finally have a Console
* Server, this code should be changed to send connection data instead.
*/
- CsrRequest = MAKE_CSR_API(ALLOC_CONSOLE, CSR_CONSOLE);
Request.Data.AllocConsoleRequest.CtrlDispatcher = ConsoleControlDispatcher;
Status = CsrClientCallServer(&Request,
NULL,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, ALLOC_CONSOLE),
sizeof(CSR_API_MESSAGE));
if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
Status = CsrClientCallServer(&Request,
CaptureBuffer,
- MAKE_CSR_API(DEFINE_DOS_DEVICE, CSR_CONSOLE),
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, DEFINE_DOS_DEVICE),
sizeof(CSR_API_MESSAGE));
CsrFreeCaptureBuffer(CaptureBuffer);
LPCWSTR lpExeName)
{
PCSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
ULONG SourceLength;
ULONG TargetLength = 0;
Request->Data.AddConsoleAlias.TargetLength = TargetLength;
- CsrRequest = MAKE_CSR_API(ADD_CONSOLE_ALIAS, CSR_CONSOLE);
Status = CsrClientCallServer(Request,
NULL,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, ADD_CONSOLE_ALIAS),
RequestLength);
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request->Status))
DWORD dwOptions)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
if (dwOptions & ~(DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS)
return INVALID_HANDLE_VALUE;
}
- CsrRequest = MAKE_CSR_API(DUPLICATE_HANDLE, CSR_NATIVE);
Request.Data.DuplicateHandleRequest.Handle = hConsole;
Request.Data.DuplicateHandleRequest.Access = dwDesiredAccess;
Request.Data.DuplicateHandleRequest.Inheritable = bInheritHandle;
Status = CsrClientCallServer(&Request,
NULL,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_NATIVE, DUPLICATE_HANDLE),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status=Request.Status))
{
{
CSR_API_MESSAGE Request;
PCSR_CAPTURE_BUFFER CaptureBuffer;
- ULONG CsrRequest = MAKE_CSR_API(EXPUNGE_COMMAND_HISTORY, CSR_CONSOLE);
NTSTATUS Status;
if (lpExeName == NULL || !(bUnicode ? *(PWCHAR)lpExeName : *(PCHAR)lpExeName))
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
+
IntCaptureMessageString(CaptureBuffer, lpExeName, bUnicode,
&Request.Data.ExpungeCommandHistory.ExeName);
- Status = CsrClientCallServer(&Request, CaptureBuffer, CsrRequest, sizeof(CSR_API_MESSAGE));
+
+ Status = CsrClientCallServer(&Request,
+ CaptureBuffer,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, EXPUNGE_COMMAND_HISTORY),
+ sizeof(CSR_API_MESSAGE));
+
CsrFreeCaptureBuffer(CaptureBuffer);
+
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
return FALSE;
}
+
return TRUE;
}
{
PCSR_API_MESSAGE Request;
PCSR_CAPTURE_BUFFER CaptureBuffer;
- ULONG CsrRequest;
NTSTATUS Status;
ULONG Size;
ULONG ExeLength;
return 0;
}
- CsrRequest = MAKE_CSR_API(GET_CONSOLE_ALIAS, CSR_CONSOLE);
-
ExeLength = wcslen(lpExeName) + 1;
SourceLength = wcslen(lpSource) + 1;
Status = CsrClientCallServer(Request,
CaptureBuffer,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_ALIAS),
sizeof(CSR_API_MESSAGE) + Size);
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request->Status))
{
CSR_API_MESSAGE Request;
PCSR_CAPTURE_BUFFER CaptureBuffer;
- ULONG CsrRequest;
NTSTATUS Status;
DPRINT("GetConsoleAliasExesW entered\n");
return 0;
}
- CsrRequest = MAKE_CSR_API(GET_CONSOLE_ALIASES_EXES, CSR_CONSOLE);
CsrAllocateMessagePointer(CaptureBuffer,
ExeNameBufferLength,
(PVOID*)&Request.Data.GetConsoleAliasesExes.ExeNames);
Status = CsrClientCallServer(&Request,
CaptureBuffer,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_ALIASES_EXES),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
GetConsoleAliasExesLengthW(VOID)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
DPRINT("GetConsoleAliasExesLengthW entered\n");
- CsrRequest = MAKE_CSR_API(GET_CONSOLE_ALIASES_EXES_LENGTH, CSR_CONSOLE);
Request.Data.GetConsoleAliasesExesLength.Length = 0;
-
Status = CsrClientCallServer(&Request,
NULL,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_ALIASES_EXES_LENGTH),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
LPWSTR ExeName)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
DWORD dwLength;
if (!dwLength || dwLength > AliasBufferLength)
return 0;
- CsrRequest = MAKE_CSR_API(GET_ALL_CONSOLE_ALIASES, CSR_CONSOLE);
Request.Data.GetAllConsoleAlias.AliasBuffer = AliasBuffer;
Request.Data.GetAllConsoleAlias.AliasBufferLength = AliasBufferLength;
Request.Data.GetAllConsoleAlias.lpExeName = ExeName;
Status = CsrClientCallServer(&Request,
NULL,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_ALL_CONSOLE_ALIASES),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
GetConsoleAliasesLengthW(LPWSTR lpExeName)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
DPRINT("GetConsoleAliasesLengthW entered\n");
- CsrRequest = MAKE_CSR_API(GET_ALL_CONSOLE_ALIASES_LENGTH, CSR_CONSOLE);
Request.Data.GetAllConsoleAliasesLength.lpExeName = lpExeName;
Request.Data.GetAllConsoleAliasesLength.Length = 0;
Status = CsrClientCallServer(&Request,
NULL,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_ALL_CONSOLE_ALIASES_LENGTH),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
CSR_API_MESSAGE Request;
PCSR_CAPTURE_BUFFER CaptureBuffer;
- ULONG CsrRequest = MAKE_CSR_API(GET_COMMAND_HISTORY, CSR_CONSOLE);
NTSTATUS Status;
DWORD HistoryLength = cbHistory * (bUnicode ? 1 : sizeof(WCHAR));
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return 0;
}
+
IntCaptureMessageString(CaptureBuffer, lpExeName, bUnicode,
&Request.Data.GetCommandHistory.ExeName);
Request.Data.GetCommandHistory.Length = HistoryLength;
CsrAllocateMessagePointer(CaptureBuffer, HistoryLength,
(PVOID*)&Request.Data.GetCommandHistory.History);
- Status = CsrClientCallServer(&Request, CaptureBuffer, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ CaptureBuffer,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_COMMAND_HISTORY),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
CsrFreeCaptureBuffer(CaptureBuffer);
cbHistory,
NULL, NULL);
}
+
CsrFreeCaptureBuffer(CaptureBuffer);
return Request.Data.GetCommandHistory.Length;
}
{
CSR_API_MESSAGE Request;
PCSR_CAPTURE_BUFFER CaptureBuffer;
- ULONG CsrRequest = MAKE_CSR_API(GET_COMMAND_HISTORY_LENGTH, CSR_CONSOLE);
NTSTATUS Status;
if (lpExeName == NULL || !(bUnicode ? *(PWCHAR)lpExeName : *(PCHAR)lpExeName))
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return 0;
}
+
IntCaptureMessageString(CaptureBuffer, lpExeName, bUnicode,
&Request.Data.GetCommandHistoryLength.ExeName);
- Status = CsrClientCallServer(&Request, CaptureBuffer, CsrRequest, sizeof(CSR_API_MESSAGE));
+
+ Status = CsrClientCallServer(&Request,
+ CaptureBuffer,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_COMMAND_HISTORY_LENGTH),
+ sizeof(CSR_API_MESSAGE));
+
CsrFreeCaptureBuffer(CaptureBuffer);
+
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
return 0;
}
+
return Request.Data.GetCommandHistoryLength.Length;
}
PDWORD State)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(SETGET_CONSOLE_HW_STATE, CSR_CONSOLE);
Request.Data.ConsoleHardwareStateRequest.ConsoleHandle = hConsole;
Request.Data.ConsoleHardwareStateRequest.SetGet = CONSOLE_HARDWARE_STATE_GET;
Status = CsrClientCallServer(&Request,
NULL,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SETGET_CONSOLE_HW_STATE),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
GetConsoleInputWaitHandle(VOID)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(GET_INPUT_WAIT_HANDLE, CSR_CONSOLE);
-
Status = CsrClientCallServer(&Request,
NULL,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_INPUT_WAIT_HANDLE),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
if (wsName && 0 == _wcsicmp(wsName, L"CONIN$"))
{
- CsrRequest = MAKE_CSR_API(GET_INPUT_HANDLE, CSR_NATIVE);
+ CsrRequest = CSR_CREATE_API_NUMBER(CSR_NATIVE, GET_INPUT_HANDLE);
}
else if (wsName && 0 == _wcsicmp(wsName, L"CONOUT$"))
{
- CsrRequest = MAKE_CSR_API(GET_OUTPUT_HANDLE, CSR_NATIVE);
+ CsrRequest = CSR_CREATE_API_NUMBER(CSR_NATIVE, GET_OUTPUT_HANDLE);
}
else
{
DWORD State)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(SETGET_CONSOLE_HW_STATE, CSR_CONSOLE);
Request.Data.ConsoleHardwareStateRequest.ConsoleHandle = hConsole;
Request.Data.ConsoleHardwareStateRequest.SetGet = CONSOLE_HARDWARE_STATE_SET;
Request.Data.ConsoleHardwareStateRequest.State = State;
Status = CsrClientCallServer(&Request,
NULL,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SETGET_CONSOLE_HW_STATE),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
{
CSR_API_MESSAGE Request;
PCSR_CAPTURE_BUFFER CaptureBuffer;
- ULONG CsrRequest = MAKE_CSR_API(SET_HISTORY_NUMBER_COMMANDS, CSR_CONSOLE);
NTSTATUS Status;
if (lpExeName == NULL || !(bUnicode ? *(PWCHAR)lpExeName : *(PCHAR)lpExeName))
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
+
IntCaptureMessageString(CaptureBuffer, lpExeName, bUnicode,
&Request.Data.SetHistoryNumberCommands.ExeName);
Request.Data.SetHistoryNumberCommands.NumCommands = dwNumCommands;
- Status = CsrClientCallServer(&Request, CaptureBuffer, CsrRequest, sizeof(CSR_API_MESSAGE));
+
+ Status = CsrClientCallServer(&Request,
+ CaptureBuffer,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_HISTORY_NUMBER_COMMANDS),
+ sizeof(CSR_API_MESSAGE));
+
CsrFreeCaptureBuffer(CaptureBuffer);
+
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
return FALSE;
}
+
return TRUE;
}
VerifyConsoleIoHandle(HANDLE Handle)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(VERIFY_HANDLE, CSR_NATIVE);
Request.Data.VerifyHandleRequest.Handle = Handle;
Status = CsrClientCallServer(&Request,
NULL,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_NATIVE, VERIFY_HANDLE),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status))
{
CloseConsoleHandle(HANDLE Handle)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(CLOSE_HANDLE, CSR_NATIVE);
Request.Data.CloseHandleRequest.Handle = Handle;
Status = CsrClientCallServer(&Request,
NULL,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_NATIVE, CLOSE_HANDLE),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status))
{
return FALSE;
}
- CsrRequest = MAKE_CSR_API(WRITE_CONSOLE, CSR_CONSOLE);
+ CsrRequest = CSR_CREATE_API_NUMBER(CSR_CONSOLE, WRITE_CONSOLE);
while (nNumberOfCharsToWrite > 0)
{
BOOL bUnicode)
{
CSR_API_MESSAGE Request;
+ ULONG CsrRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer;
- ULONG CsrRequest = MAKE_CSR_API(READ_CONSOLE, CSR_CONSOLE);
NTSTATUS Status = STATUS_SUCCESS;
ULONG CharSize = (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
Request.Data.ReadConsoleRequest.CtrlWakeupMask = pInputControl->dwCtrlWakeupMask;
}
+ CsrRequest = CSR_CREATE_API_NUMBER(CSR_CONSOLE, READ_CONSOLE);
+
do
{
if (Status == STATUS_PENDING)
}
}
- Status = CsrClientCallServer(&Request, CaptureBuffer, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ CaptureBuffer,
+ CsrRequest,
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
DPRINT1("CSR returned error in ReadConsole\n");
AllocConsole(VOID)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
HANDLE hStdError;
STARTUPINFO si;
Request.Data.AllocConsoleRequest.ConsoleNeeded = TRUE;
Request.Data.AllocConsoleRequest.ShowCmd = si.wShowWindow;
- CsrRequest = MAKE_CSR_API(ALLOC_CONSOLE, CSR_CONSOLE);
-
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, ALLOC_CONSOLE),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
// but I just tried to reverse what AllocConsole() does...
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(FREE_CONSOLE, CSR_CONSOLE);
-
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, FREE_CONSOLE),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(SCREEN_BUFFER_INFO, CSR_CONSOLE);
Request.Data.ScreenBufferInfoRequest.ConsoleHandle = hConsoleOutput;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SCREEN_BUFFER_INFO),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
COORD dwCursorPosition)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(SET_CURSOR, CSR_CONSOLE);
Request.Data.SetCursorRequest.ConsoleHandle = hConsoleOutput;
Request.Data.SetCursorRequest.Position = dwCursorPosition;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_CURSOR),
+ sizeof(CSR_API_MESSAGE));
if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
BOOL bUnicode)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(FILL_OUTPUT, CSR_CONSOLE);
Request.Data.FillOutputRequest.ConsoleHandle = hConsoleOutput;
Request.Data.FillOutputRequest.Unicode = bUnicode;
Status = CsrClientCallServer(&Request,
NULL,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, FILL_OUTPUT),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
BOOL bUnicode)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer;
ULONG Size;
(PVOID*)&Request.Data.PeekConsoleInputRequest.InputRecord);
/* Set up the data to send to the Console Server */
- CsrRequest = MAKE_CSR_API(PEEK_CONSOLE_INPUT, CSR_CONSOLE);
Request.Data.PeekConsoleInputRequest.ConsoleHandle = hConsoleInput;
Request.Data.PeekConsoleInputRequest.Unicode = bUnicode;
Request.Data.PeekConsoleInputRequest.Length = nLength;
/* Call the server */
CsrClientCallServer(&Request,
CaptureBuffer,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, PEEK_CONSOLE_INPUT),
sizeof(CSR_API_MESSAGE));
DPRINT("Server returned: %x\n", Request.Status);
ULONG Read;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(READ_INPUT, CSR_CONSOLE);
+ CsrRequest = CSR_CREATE_API_NUMBER(CSR_CONSOLE, READ_INPUT);
Read = 0;
while (nLength > 0)
BOOL bUnicode)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer;
DWORD Size;
(PVOID*)&Request.Data.WriteConsoleInputRequest.InputRecord);
/* Set up the data to send to the Console Server */
- CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_INPUT, CSR_CONSOLE);
Request.Data.WriteConsoleInputRequest.ConsoleHandle = hConsoleInput;
Request.Data.WriteConsoleInputRequest.Unicode = bUnicode;
Request.Data.WriteConsoleInputRequest.Length = nLength;
/* Call the server */
CsrClientCallServer(&Request,
CaptureBuffer,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, WRITE_CONSOLE_INPUT),
sizeof(CSR_API_MESSAGE));
DPRINT("Server returned: %x\n", Request.Status);
BOOL bUnicode)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer;
DWORD Size, SizeX, SizeY;
(PVOID*)&Request.Data.ReadConsoleOutputRequest.CharInfo);
/* Set up the data to send to the Console Server */
- CsrRequest = MAKE_CSR_API(READ_CONSOLE_OUTPUT, CSR_CONSOLE);
Request.Data.ReadConsoleOutputRequest.ConsoleHandle = hConsoleOutput;
Request.Data.ReadConsoleOutputRequest.Unicode = bUnicode;
Request.Data.ReadConsoleOutputRequest.BufferSize = dwBufferSize;
/* Call the server */
CsrClientCallServer(&Request,
CaptureBuffer,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, READ_CONSOLE_OUTPUT),
sizeof(CSR_API_MESSAGE));
DPRINT("Server returned: %x\n", Request.Status);
BOOL bUnicode)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer;
ULONG Size;
RtlCopyMemory(Request.Data.WriteConsoleOutputRequest.CharInfo, lpBuffer, Size);
/* Set up the data to send to the Console Server */
- CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_OUTPUT, CSR_CONSOLE);
Request.Data.WriteConsoleOutputRequest.ConsoleHandle = hConsoleOutput;
Request.Data.WriteConsoleOutputRequest.Unicode = bUnicode;
Request.Data.WriteConsoleOutputRequest.BufferSize = dwBufferSize;
/* Call the server */
CsrClientCallServer(&Request,
CaptureBuffer,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, WRITE_CONSOLE_OUTPUT),
sizeof(CSR_API_MESSAGE));
DPRINT("Server returned: %x\n", Request.Status);
return FALSE;
}
- CsrRequest = MAKE_CSR_API(READ_CONSOLE_OUTPUT_CHAR, CSR_CONSOLE);
+ CsrRequest = CSR_CREATE_API_NUMBER(CSR_CONSOLE, READ_CONSOLE_OUTPUT_CHAR);
Request->Data.ReadConsoleOutputCharRequest.ReadCoord = dwReadCoord;
while (nLength > 0)
return FALSE;
}
- CsrRequest = MAKE_CSR_API(READ_CONSOLE_OUTPUT_ATTRIB, CSR_CONSOLE);
+ CsrRequest = CSR_CREATE_API_NUMBER(CSR_CONSOLE, READ_CONSOLE_OUTPUT_ATTRIB);
while (nLength != 0)
{
return FALSE;
}
- CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_OUTPUT_CHAR, CSR_CONSOLE);
+ CsrRequest = CSR_CREATE_API_NUMBER(CSR_CONSOLE, WRITE_CONSOLE_OUTPUT_CHAR);
Request->Data.WriteConsoleOutputCharRequest.Coord = dwWriteCoord;
while (nLength > 0)
return FALSE;
}
- CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_OUTPUT_ATTRIB, CSR_CONSOLE);
+ CsrRequest = CSR_CREATE_API_NUMBER(CSR_CONSOLE, WRITE_CONSOLE_OUTPUT_ATTRIB);
Request->Data.WriteConsoleOutputAttribRequest.Coord = dwWriteCoord;
if (lpNumberOfAttrsWritten)
LPDWORD lpNumberOfAttrsWritten)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(FILL_OUTPUT_ATTRIB, CSR_CONSOLE);
Request.Data.FillOutputAttribRequest.ConsoleHandle = hConsoleOutput;
Request.Data.FillOutputAttribRequest.Attribute = (CHAR)wAttribute;
Request.Data.FillOutputAttribRequest.Coord = dwWriteCoord;
Request.Data.FillOutputAttribRequest.Length = (WORD)nLength;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, FILL_OUTPUT_ATTRIB),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError ( Status );
LPDWORD lpMode)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(GET_CONSOLE_MODE, CSR_CONSOLE);
Request.Data.GetConsoleModeRequest.ConsoleHandle = hConsoleHandle;
- Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_MODE),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
- BaseSetLastNTError ( Status );
+ BaseSetLastNTError(Status);
return FALSE;
}
+
*lpMode = Request.Data.GetConsoleModeRequest.ConsoleMode;
return TRUE;
LPDWORD lpNumberOfEvents)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
if (lpNumberOfEvents == NULL)
return FALSE;
}
- CsrRequest = MAKE_CSR_API(GET_NUM_INPUT_EVENTS, CSR_CONSOLE);
Request.Data.GetNumInputEventsRequest.ConsoleHandle = hConsoleInput;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_NUM_INPUT_EVENTS),
+ sizeof(CSR_API_MESSAGE));
if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
PCONSOLE_CURSOR_INFO lpConsoleCursorInfo)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
if (!lpConsoleCursorInfo)
return FALSE;
}
- CsrRequest = MAKE_CSR_API(GET_CURSOR_INFO, CSR_CONSOLE);
Request.Data.GetCursorInfoRequest.ConsoleHandle = hConsoleOutput;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
-
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CURSOR_INFO),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
return FALSE;
}
+
*lpConsoleCursorInfo = Request.Data.GetCursorInfoRequest.Info;
return TRUE;
DWORD dwMode)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(SET_CONSOLE_MODE, CSR_CONSOLE);
Request.Data.SetConsoleModeRequest.ConsoleHandle = hConsoleHandle;
Request.Data.SetConsoleModeRequest.Mode = dwMode;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_CONSOLE_MODE),
+ sizeof(CSR_API_MESSAGE));
if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
- BaseSetLastNTError ( Status );
+ BaseSetLastNTError(Status);
return FALSE;
}
SetConsoleActiveScreenBuffer(HANDLE hConsoleOutput)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(SET_SCREEN_BUFFER, CSR_CONSOLE);
Request.Data.SetScreenBufferRequest.OutputHandle = hConsoleOutput;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_SCREEN_BUFFER),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
FlushConsoleInputBuffer(HANDLE hConsoleInput)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(FLUSH_INPUT_BUFFER, CSR_CONSOLE);
Request.Data.FlushInputBufferRequest.ConsoleInput = hConsoleInput;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, FLUSH_INPUT_BUFFER),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
COORD dwSize)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(SET_SCREEN_BUFFER_SIZE, CSR_CONSOLE);
Request.Data.SetScreenBufferSize.OutputHandle = hConsoleOutput;
Request.Data.SetScreenBufferSize.Size = dwSize;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_SCREEN_BUFFER_SIZE),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
CONST CONSOLE_CURSOR_INFO *lpConsoleCursorInfo)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(SET_CURSOR_INFO, CSR_CONSOLE);
Request.Data.SetCursorInfoRequest.ConsoleHandle = hConsoleOutput;
Request.Data.SetCursorInfoRequest.Info = *lpConsoleCursorInfo;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_CURSOR_INFO),
+ sizeof(CSR_API_MESSAGE));
if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
BOOL bUnicode)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(SCROLL_CONSOLE_SCREEN_BUFFER, CSR_CONSOLE);
Request.Data.ScrollConsoleScreenBufferRequest.ConsoleHandle = hConsoleOutput;
Request.Data.ScrollConsoleScreenBufferRequest.Unicode = bUnicode;
Request.Data.ScrollConsoleScreenBufferRequest.ScrollRectangle = *lpScrollRectangle;
Status = CsrClientCallServer(&Request,
NULL,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SCROLL_CONSOLE_SCREEN_BUFFER),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
WORD wAttributes)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(SET_ATTRIB, CSR_CONSOLE);
Request.Data.SetAttribRequest.ConsoleHandle = hConsoleOutput;
Request.Data.SetAttribRequest.Attrib = wAttributes;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_ATTRIB),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
DWORD dwProcessGroupId)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
if (dwCtrlEvent != CTRL_C_EVENT && dwCtrlEvent != CTRL_BREAK_EVENT)
return FALSE;
}
- CsrRequest = MAKE_CSR_API(GENERATE_CTRL_EVENT, CSR_CONSOLE);
Request.Data.GenerateCtrlEvent.Event = dwCtrlEvent;
Request.Data.GenerateCtrlEvent.ProcessGroup = dwProcessGroupId;
Status = CsrClientCallServer(&Request,
NULL,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GENERATE_CTRL_EVENT),
sizeof(CSR_API_MESSAGE));
if(!NT_SUCCESS(Status) || !(NT_SUCCESS(Status = Request.Status)))
{
{
CSR_API_MESSAGE Request;
PCSR_CAPTURE_BUFFER CaptureBuffer;
- ULONG CsrRequest = MAKE_CSR_API(GET_TITLE, CSR_CONSOLE);
NTSTATUS Status;
if (nSize == 0)
Request.Data.GetTitleRequest.Length,
(PVOID*)&Request.Data.GetTitleRequest.Title);
- Status = CsrClientCallServer(&Request, CaptureBuffer, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ CaptureBuffer,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_TITLE),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !(NT_SUCCESS(Status = Request.Status)))
{
CsrFreeCaptureBuffer(CaptureBuffer);
{
CSR_API_MESSAGE Request;
PCSR_CAPTURE_BUFFER CaptureBuffer;
- ULONG CsrRequest = MAKE_CSR_API(SET_TITLE, CSR_CONSOLE);
NTSTATUS Status;
Request.Data.SetTitleRequest.Length = wcslen(lpConsoleTitle) * sizeof(WCHAR);
Request.Data.SetTitleRequest.Length,
(PVOID*)&Request.Data.SetTitleRequest.Title);
- Status = CsrClientCallServer(&Request, CaptureBuffer, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ CaptureBuffer,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_TITLE),
+ sizeof(CSR_API_MESSAGE));
+
CsrFreeCaptureBuffer(CaptureBuffer);
+
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
LPVOID lpScreenBufferData)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
if (dwDesiredAccess & ~(GENERIC_READ | GENERIC_WRITE)
Request.Data.CreateScreenBufferRequest.Inheritable =
lpSecurityAttributes ? lpSecurityAttributes->bInheritHandle : FALSE;
- CsrRequest = MAKE_CSR_API(CREATE_SCREEN_BUFFER, CSR_CONSOLE);
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, CREATE_SCREEN_BUFFER),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
GetConsoleCP(VOID)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(GET_CONSOLE_CP, CSR_CONSOLE);
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_CP),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError (Status);
SetConsoleCP(UINT wCodePageID)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(SET_CONSOLE_CP, CSR_CONSOLE);
Request.Data.SetConsoleCodePage.CodePage = wCodePageID;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_CONSOLE_CP),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
GetConsoleOutputCP(VOID)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(GET_CONSOLE_OUTPUT_CP, CSR_CONSOLE);
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_OUTPUT_CP),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError (Status);
SetConsoleOutputCP(UINT wCodePageID)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(SET_CONSOLE_OUTPUT_CP, CSR_CONSOLE);
Request.Data.SetConsoleOutputCodePage.CodePage = wCodePageID;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_CONSOLE_OUTPUT_CP),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
{
PCSR_CAPTURE_BUFFER CaptureBuffer;
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
ULONG nProcesses;
NTSTATUS Status;
return FALSE;
}
- CsrRequest = MAKE_CSR_API(GET_PROCESS_LIST, CSR_CONSOLE);
Request.Data.GetProcessListRequest.nMaxIds = dwProcessCount;
CsrAllocateMessagePointer(CaptureBuffer,
dwProcessCount * sizeof(DWORD),
Status = CsrClientCallServer(&Request,
CaptureBuffer,
- CsrRequest,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_PROCESS_LIST),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
GetConsoleSelectionInfo(PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest = MAKE_CSR_API(GET_CONSOLE_SELECTION_INFO, CSR_CONSOLE);
- NTSTATUS Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ NTSTATUS Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_SELECTION_INFO),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
GetConsoleWindow(VOID)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(GET_CONSOLE_WINDOW, CSR_CONSOLE);
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_WINDOW),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status ) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
SetConsoleIcon(HICON hicon)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest;
NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(SET_CONSOLE_ICON, CSR_CONSOLE);
Request.Data.SetConsoleIconRequest.WindowIcon = hicon;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_CONSOLE_ICON),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
{
CsrClientCallServer(&ApiMessage,
NULL,
- MAKE_CSR_API(SOUND_SENTRY, CSR_NATIVE),
+ CSR_CREATE_API_NUMBER(CSR_NATIVE, SOUND_SENTRY),
sizeof(CSR_API_MESSAGE));
}
}
/* If user didn't gave any ID, ask Csrss to give one */
if (!uUnique)
{
- CsrClientCallServer(&ApiMessage, NULL, MAKE_CSR_API(GET_TEMP_FILE, CSR_NATIVE), sizeof(CSR_API_MESSAGE));
+ CsrClientCallServer(&ApiMessage,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_NATIVE, GET_TEMP_FILE),
+ sizeof(CSR_API_MESSAGE));
if (ApiMessage.Data.GetTempFile.UniqueID == 0)
{
Num++;
/* Call CSR */
Status = CsrClientCallServer(&CsrRequest,
NULL,
- MAKE_CSR_API(Request, CSR_NATIVE),
+ CSR_CREATE_API_NUMBER(CSR_NATIVE, Request),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status))
{
/* Call CSR */
Status = CsrClientCallServer(&CsrRequest,
NULL,
- MAKE_CSR_API(Request, CSR_NATIVE),
+ CSR_CREATE_API_NUMBER(CSR_NATIVE, Request),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status))
{
/* Ask CSRSS for shutdown information */
Status = CsrClientCallServer(&CsrRequest,
NULL,
- MAKE_CSR_API(GET_SHUTDOWN_PARAMETERS, CSR_NATIVE),
+ CSR_CREATE_API_NUMBER(CSR_NATIVE, GET_SHUTDOWN_PARAMETERS),
sizeof(CSR_API_MESSAGE));
if (!(NT_SUCCESS(Status)) || !(NT_SUCCESS(CsrRequest.Status)))
{
CsrRequest.Data.SetShutdownParametersRequest.Flags = dwFlags;
Status = CsrClientCallServer(&CsrRequest,
NULL,
- MAKE_CSR_API(SET_SHUTDOWN_PARAMETERS, CSR_NATIVE),
+ CSR_CREATE_API_NUMBER(CSR_NATIVE, SET_SHUTDOWN_PARAMETERS),
sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status))
{
CsrRequest.Data.TerminateProcessRequest.uExitCode = uExitCode;
CsrClientCallServer(&CsrRequest,
NULL,
- MAKE_CSR_API(TERMINATE_PROCESS, CSR_NATIVE),
+ CSR_CREATE_API_NUMBER(CSR_NATIVE, TERMINATE_PROCESS),
sizeof(CSR_API_MESSAGE));
/* Now do it again */
{
NTSTATUS Status;
CSR_API_MESSAGE Msg;
- ULONG CsrRequest = MAKE_CSR_API(UPDATE_VDM_ENTRY, CSR_CONSOLE);
/* Check what update is being sent */
switch (UpdateIndex)
Msg.Data.UpdateVdmEntry.BinaryType = BinaryType;
/* Send the message to CSRSS */
- Status = CsrClientCallServer(&Msg, NULL, CsrRequest, sizeof(Msg));
+ Status = CsrClientCallServer(&Msg,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, UPDATE_VDM_ENTRY),
+ sizeof(Msg));
if (!(NT_SUCCESS(Status)) || !(NT_SUCCESS(Msg.Status)))
{
/* Handle failure */
NTSTATUS Status;
EVENT_BASIC_INFORMATION EventBasicInfo;
CSR_API_MESSAGE Msg;
- ULONG CsrRequest = MAKE_CSR_API(GET_VDM_EXIT_CODE, CSR_CONSOLE);
/* It's VDM if the process is actually a wait handle (an event) */
Status = NtQueryEvent(ProcessHandle,
Msg.Data.GetVdmExitCode.hParent = ProcessHandle;
/* Call CSRSS */
- Status = CsrClientCallServer(&Msg, NULL, CsrRequest, sizeof(Msg));
+ Status = CsrClientCallServer(&Msg,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_VDM_EXIT_CODE),
+ sizeof(Msg));
if (!NT_SUCCESS(Status)) return FALSE;
/* Get the exit code from the reply */
GetConsoleHistoryInfo(PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest = MAKE_CSR_API(GET_HISTORY_INFO, CSR_CONSOLE);
NTSTATUS Status;
+
if (lpConsoleHistoryInfo->cbSize != sizeof(CONSOLE_HISTORY_INFO))
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_HISTORY_INFO),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
return FALSE;
}
+
lpConsoleHistoryInfo->HistoryBufferSize = Request.Data.GetHistoryInfo.HistoryBufferSize;
lpConsoleHistoryInfo->NumberOfHistoryBuffers = Request.Data.GetHistoryInfo.NumberOfHistoryBuffers;
lpConsoleHistoryInfo->dwFlags = Request.Data.GetHistoryInfo.dwFlags;
+
return TRUE;
}
SetConsoleHistoryInfo(IN PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo)
{
CSR_API_MESSAGE Request;
- ULONG CsrRequest = MAKE_CSR_API(GET_HISTORY_INFO, CSR_CONSOLE);
NTSTATUS Status;
+
if (lpConsoleHistoryInfo->cbSize != sizeof(CONSOLE_HISTORY_INFO))
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
+
Request.Data.SetHistoryInfo.HistoryBufferSize = lpConsoleHistoryInfo->HistoryBufferSize;
Request.Data.SetHistoryInfo.NumberOfHistoryBuffers = lpConsoleHistoryInfo->NumberOfHistoryBuffers;
Request.Data.SetHistoryInfo.dwFlags = lpConsoleHistoryInfo->dwFlags;
- Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_HISTORY_INFO),
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
BaseSetLastNTError(Status);
return FALSE;
}
+
return TRUE;
}
#include <ndk/umfuncs.h>
/* CSRSS Header */
-#include <csrss/csrss.h>
+#include <csrss/client.h>
+#include <csrss/csrss.h> // FIXME: data header.
/* C Headers */
#include <ctype.h>
#include <umtypes.h>
#include <dbgktypes.h>
-//
-// Don't force inclusion of csrss header, leave this opaque.
-//
-struct _CSR_API_MESSAGE;
-struct _CSR_CAPTURE_BUFFER;
-
-//
-// CSR Functions
-//
-PVOID
-NTAPI
-CsrAllocateCaptureBuffer(
- ULONG ArgumentCount,
- ULONG BufferSize
-);
-
-ULONG
-NTAPI
-CsrAllocateMessagePointer(
- struct _CSR_CAPTURE_BUFFER *CaptureBuffer,
- ULONG MessageLength,
- PVOID *CaptureData
-);
-
-VOID
-NTAPI
-CsrCaptureMessageBuffer(
- struct _CSR_CAPTURE_BUFFER *CaptureBuffer,
- PVOID MessageString,
- ULONG StringLength,
- PVOID *CapturedData
-);
-
-NTSTATUS
-NTAPI
-CsrClientConnectToServer(
- PWSTR ObjectDirectory,
- ULONG ServerId,
- PVOID ConnectionInfo,
- PULONG ConnectionInfoSize,
- PBOOLEAN ServerToServerCall
-);
-
-NTSTATUS
-NTAPI
-CsrClientCallServer(
- struct _CSR_API_MESSAGE *Request,
- struct _CSR_CAPTURE_BUFFER *CaptureBuffer OPTIONAL,
- ULONG ApiNumber,
- ULONG RequestLength
-);
-
-NTSTATUS
-NTAPI
-CsrIdentifyAlertableThread(
- VOID
-);
-
-VOID
-NTAPI
-CsrFreeCaptureBuffer(
- struct _CSR_CAPTURE_BUFFER *CaptureBuffer
-);
-
-HANDLE
-NTAPI
-CsrGetProcessId(
- VOID
-);
-
-NTSTATUS
-NTAPI
-CsrNewThread(VOID);
-
-NTSTATUS
-NTAPI
-CsrSetPriorityClass(
- HANDLE Process,
- PULONG PriorityClass
-);
-
-VOID
-NTAPI
-CsrProbeForRead(
- IN PVOID Address,
- IN ULONG Length,
- IN ULONG Alignment
-);
-
-VOID
-NTAPI
-CsrProbeForWrite(
- IN PVOID Address,
- IN ULONG Length,
- IN ULONG Alignment
-);
-
//
// Debug Functions
//
#define MAXUSHORT 0xffff
#define MAXULONG 0xffffffff
-//
-// CSR Macros
-//
-#define CSR_MAKE_OPCODE(s,m) ((s) << 16) | (m)
-#define CSR_API_ID_FROM_OPCODE(n) ((ULONG)((USHORT)(n)))
-#define CSR_SERVER_ID_FROM_OPCODE(n) (ULONG)((n) >> 16)
-
//
// Basic Types that aren't defined in User-Mode Headers
//
--- /dev/null
+/*
+ * PROJECT: ReactOS Native Headers
+ * FILE: include/subsys/csrss/client.h
+ * PURPOSE: Public Definitions for CSR Clients
+ * PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
+ * Hermes Belusca-Maito (hermes.belusca@sfr.fr)
+ */
+
+#ifndef _CSRCLIENT_H
+#define _CSRCLIENT_H
+
+#include "msg.h"
+
+/*
+BOOLEAN
+NTAPI
+CsrCaptureArguments(IN PCSR_THREAD CsrThread,
+ IN PCSR_API_MESSAGE ApiMessage);
+
+VOID
+NTAPI
+CsrReleaseCapturedArguments(IN PCSR_API_MESSAGE ApiMessage);
+*/
+
+NTSTATUS
+NTAPI
+CsrClientConnectToServer(IN PWSTR ObjectDirectory,
+ IN ULONG ServerId,
+ IN PVOID ConnectionInfo,
+ IN OUT PULONG ConnectionInfoSize,
+ OUT PBOOLEAN ServerToServerCall);
+
+NTSTATUS
+NTAPI
+CsrClientCallServer(IN OUT PCSR_API_MESSAGE Request,
+ IN OUT PCSR_CAPTURE_BUFFER CaptureBuffer OPTIONAL,
+ IN ULONG ApiNumber,
+ IN ULONG RequestLength);
+
+PVOID
+NTAPI
+CsrAllocateCaptureBuffer(IN ULONG ArgumentCount,
+ IN ULONG BufferSize);
+
+VOID
+NTAPI
+CsrFreeCaptureBuffer(IN PCSR_CAPTURE_BUFFER CaptureBuffer);
+
+ULONG
+NTAPI
+CsrAllocateMessagePointer(IN OUT PCSR_CAPTURE_BUFFER CaptureBuffer,
+ IN ULONG MessageLength,
+ OUT PVOID* CaptureData);
+
+VOID
+NTAPI
+CsrCaptureMessageBuffer(IN OUT PCSR_CAPTURE_BUFFER CaptureBuffer,
+ IN PVOID MessageString,
+ IN ULONG StringLength,
+ OUT PVOID* CapturedData);
+
+BOOLEAN
+NTAPI
+CsrValidateMessageBuffer(IN PCSR_API_MESSAGE ApiMessage,
+ IN PVOID* Buffer,
+ IN ULONG ArgumentSize,
+ IN ULONG ArgumentCount);
+
+VOID
+NTAPI
+CsrProbeForRead(IN PVOID Address,
+ IN ULONG Length,
+ IN ULONG Alignment);
+
+VOID
+NTAPI
+CsrProbeForWrite(IN PVOID Address,
+ IN ULONG Length,
+ IN ULONG Alignment);
+
+NTSTATUS
+NTAPI
+CsrIdentifyAlertableThread(VOID);
+
+HANDLE
+NTAPI
+CsrGetProcessId(VOID);
+
+NTSTATUS
+NTAPI
+CsrNewThread(VOID);
+
+NTSTATUS
+NTAPI
+CsrSetPriorityClass(IN HANDLE Process,
+ IN OUT PULONG PriorityClass);
+
+#endif // _CSRCLIENT_H
+
+/* EOF */
--- /dev/null
+/*
+ * CSRSS Console management structures.
+ */
+
+#ifndef __CSRCONS_H__
+#define __CSRCONS_H__
+
+#include <drivers/blue/ntddblue.h>
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ BOOL Unicode;
+ ULONG NrCharactersToWrite;
+ ULONG NrCharactersWritten;
+ HANDLE UnpauseEvent;
+ BYTE Buffer[0];
+} CSRSS_WRITE_CONSOLE, *PCSRSS_WRITE_CONSOLE;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ BOOL Unicode;
+ WORD NrCharactersToRead;
+ WORD NrCharactersRead;
+ HANDLE EventHandle;
+ PVOID Buffer;
+ UNICODE_STRING ExeName;
+ DWORD CtrlWakeupMask;
+ DWORD ControlKeyState;
+} CSRSS_READ_CONSOLE, *PCSRSS_READ_CONSOLE;
+
+typedef struct
+{
+ PCONTROLDISPATCHER CtrlDispatcher;
+ BOOLEAN ConsoleNeeded;
+ INT ShowCmd;
+ HANDLE Console;
+ HANDLE InputHandle;
+ HANDLE OutputHandle;
+} CSRSS_ALLOC_CONSOLE, *PCSRSS_ALLOC_CONSOLE;
+
+typedef struct
+{
+ ULONG Dummy;
+} CSRSS_FREE_CONSOLE, *PCSRSS_FREE_CONSOLE;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ CONSOLE_SCREEN_BUFFER_INFO Info;
+} CSRSS_SCREEN_BUFFER_INFO, *PCSRSS_SCREEN_BUFFER_INFO;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ COORD Position;
+} CSRSS_SET_CURSOR, *PCSRSS_SET_CURSOR;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ BOOL Unicode;
+ union
+ {
+ CHAR AsciiChar;
+ WCHAR UnicodeChar;
+ } Char;
+ COORD Position;
+ WORD Length;
+ ULONG NrCharactersWritten;
+} CSRSS_FILL_OUTPUT, *PCSRSS_FILL_OUTPUT;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ CHAR Attribute;
+ COORD Coord;
+ WORD Length;
+} CSRSS_FILL_OUTPUT_ATTRIB, *PCSRSS_FILL_OUTPUT_ATTRIB;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ BOOL Unicode;
+ INPUT_RECORD Input;
+ BOOL MoreEvents;
+ HANDLE Event;
+} CSRSS_READ_INPUT, *PCSRSS_READ_INPUT;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ BOOL Unicode;
+ WORD Length;
+ COORD Coord;
+ COORD EndCoord;
+ ULONG NrCharactersWritten;
+ CHAR String[0];
+} CSRSS_WRITE_CONSOLE_OUTPUT_CHAR, *PCSRSS_WRITE_CONSOLE_OUTPUT_CHAR;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ WORD Length;
+ COORD Coord;
+ COORD EndCoord;
+ WORD Attribute[0];
+} CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB, *PCSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ CONSOLE_CURSOR_INFO Info;
+} CSRSS_GET_CURSOR_INFO, *PCSRSS_GET_CURSOR_INFO;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ CONSOLE_CURSOR_INFO Info;
+} CSRSS_SET_CURSOR_INFO, *PCSRSS_SET_CURSOR_INFO;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ WORD Attrib;
+} CSRSS_SET_ATTRIB, *PCSRSS_SET_ATTRIB;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ DWORD Mode;
+} CSRSS_SET_CONSOLE_MODE, *PCSRSS_SET_CONSOLE_MODE;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ DWORD ConsoleMode;
+} CSRSS_GET_CONSOLE_MODE, *PCSRSS_GET_CONSOLE_MODE;
+
+typedef struct
+{
+ DWORD Access;
+ DWORD ShareMode;
+ BOOL Inheritable;
+ HANDLE OutputHandle; /* handle to newly created screen buffer */
+} CSRSS_CREATE_SCREEN_BUFFER, *PCSRSS_CREATE_SCREEN_BUFFER;
+
+typedef struct
+{
+ HANDLE OutputHandle; /* handle to screen buffer to switch to */
+} CSRSS_SET_SCREEN_BUFFER, *PCSRSS_SET_SCREEN_BUFFER;
+
+typedef struct
+{
+ DWORD Length;
+ PWCHAR Title;
+} CSRSS_SET_TITLE, *PCSRSS_SET_TITLE;
+
+typedef struct
+{
+ DWORD Length;
+ PWCHAR Title;
+} CSRSS_GET_TITLE, *PCSRSS_GET_TITLE;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ BOOL Unicode;
+ COORD BufferSize;
+ COORD BufferCoord;
+ SMALL_RECT WriteRegion;
+ CHAR_INFO* CharInfo;
+} CSRSS_WRITE_CONSOLE_OUTPUT, *PCSRSS_WRITE_CONSOLE_OUTPUT;
+
+typedef struct
+{
+ HANDLE ConsoleInput;
+} CSRSS_FLUSH_INPUT_BUFFER, *PCSRSS_FLUSH_INPUT_BUFFER;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ BOOL Unicode;
+ SMALL_RECT ScrollRectangle;
+ BOOLEAN UseClipRectangle;
+ SMALL_RECT ClipRectangle;
+ COORD DestinationOrigin;
+ CHAR_INFO Fill;
+} CSRSS_SCROLL_CONSOLE_SCREEN_BUFFER, *PCSRSS_SCROLL_CONSOLE_SCREEN_BUFFER;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ BOOL Unicode;
+ DWORD NumCharsToRead;
+ COORD ReadCoord;
+ COORD EndCoord;
+ DWORD CharsRead;
+ CHAR String[0];
+} CSRSS_READ_CONSOLE_OUTPUT_CHAR, *PCSRSS_READ_CONSOLE_OUTPUT_CHAR;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ DWORD NumAttrsToRead;
+ COORD ReadCoord;
+ COORD EndCoord;
+ WORD Attribute[0];
+} CSRSS_READ_CONSOLE_OUTPUT_ATTRIB, *PCSRSS_READ_CONSOLE_OUTPUT_ATTRIB;
+
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ BOOL Unicode;
+ DWORD Length;
+ INPUT_RECORD* InputRecord;
+} CSRSS_PEEK_CONSOLE_INPUT, *PCSRSS_PEEK_CONSOLE_INPUT;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ BOOL Unicode;
+ COORD BufferSize;
+ COORD BufferCoord;
+ SMALL_RECT ReadRegion;
+ CHAR_INFO* CharInfo;
+} CSRSS_READ_CONSOLE_OUTPUT, *PCSRSS_READ_CONSOLE_OUTPUT;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ BOOL Unicode;
+ DWORD Length;
+ INPUT_RECORD* InputRecord;
+} CSRSS_WRITE_CONSOLE_INPUT, *PCSRSS_WRITE_CONSOLE_INPUT;
+
+typedef struct
+{
+ DWORD Access;
+ BOOL Inheritable;
+ HANDLE Handle;
+ DWORD ShareMode;
+} CSRSS_GET_INPUT_HANDLE, *PCSRSS_GET_INPUT_HANDLE,
+ CSRSS_GET_OUTPUT_HANDLE, *PCSRSS_GET_OUTPUT_HANDLE;
+
+
+#define CONSOLE_HARDWARE_STATE_GET 0
+#define CONSOLE_HARDWARE_STATE_SET 1
+
+#define CONSOLE_HARDWARE_STATE_GDI_MANAGED 0
+#define CONSOLE_HARDWARE_STATE_DIRECT 1
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ DWORD SetGet; /* 0=get; 1=set */
+ DWORD State;
+} CSRSS_SETGET_CONSOLE_HW_STATE, *PCSRSS_SETGET_CONSOLE_HW_STATE;
+
+typedef struct
+{
+ HWND WindowHandle;
+} CSRSS_GET_CONSOLE_WINDOW, *PCSRSS_GET_CONSOLE_WINDOW;
+
+typedef struct
+{
+ HICON WindowIcon;
+} CSRSS_SET_CONSOLE_ICON, *PCSRSS_SET_CONSOLE_ICON;
+
+typedef struct
+{
+ ULONG SourceLength;
+ ULONG ExeLength;
+ ULONG TargetLength;
+} CSRSS_ADD_CONSOLE_ALIAS, *PCSRSS_ADD_CONSOLE_ALIAS;
+
+typedef struct
+{
+ ULONG SourceLength;
+ ULONG ExeLength;
+ ULONG BytesWritten;
+ ULONG TargetBufferLength;
+ PVOID TargetBuffer;
+} CSRSS_GET_CONSOLE_ALIAS, *PCSRSS_GET_CONSOLE_ALIAS;
+
+typedef struct
+{
+ LPWSTR lpExeName;
+ DWORD BytesWritten;
+ DWORD AliasBufferLength;
+ LPWSTR AliasBuffer;
+} CSRSS_GET_ALL_CONSOLE_ALIASES, *PCSRSS_GET_ALL_CONSOLE_ALIAS;
+
+typedef struct
+{
+ LPWSTR lpExeName;
+ DWORD Length;
+} CSRSS_GET_ALL_CONSOLE_ALIASES_LENGTH, *PCSRSS_GET_ALL_CONSOLE_ALIASES_LENGTH;
+
+typedef struct
+{
+ DWORD BytesWritten;
+ DWORD Length;
+ LPWSTR ExeNames;
+} CSRSS_GET_CONSOLE_ALIASES_EXES, *PCSRSS_GET_CONSOLE_ALIASES_EXES;
+
+typedef struct
+{
+ DWORD Length;
+} CSRSS_GET_CONSOLE_ALIASES_EXES_LENGTH, *PCSRSS_GET_CONSOLE_ALIASES_EXES_LENGTH;
+
+typedef struct
+{
+ DWORD Event;
+ DWORD ProcessGroup;
+} CSRSS_GENERATE_CTRL_EVENT, *PCSRSS_GENERATE_CTRL_EVENT;
+
+typedef struct
+{
+ HANDLE ConsoleHandle;
+ DWORD NumInputEvents;
+} CSRSS_GET_NUM_INPUT_EVENTS, *PCSRSS_GET_NUM_INPUT_EVENTS;
+
+typedef struct
+{
+ HANDLE OutputHandle;
+ COORD Size;
+} CSRSS_SET_SCREEN_BUFFER_SIZE, *PCSRSS_SET_SCREEN_BUFFER_SIZE;
+
+typedef struct
+{
+ CONSOLE_SELECTION_INFO Info;
+} CSRSS_GET_CONSOLE_SELECTION_INFO, *PCSRSS_GET_CONSOLE_SELECTION_INFO;
+
+typedef struct
+{
+ UNICODE_STRING ExeName;
+ DWORD Length;
+} CSRSS_GET_COMMAND_HISTORY_LENGTH, *PCSRSS_GET_COMMAND_HISTORY_LENGTH;
+
+typedef struct
+{
+ UNICODE_STRING ExeName;
+ PWCHAR History;
+ DWORD Length;
+} CSRSS_GET_COMMAND_HISTORY, *PCSRSS_GET_COMMAND_HISTORY;
+
+typedef struct
+{
+ UNICODE_STRING ExeName;
+} CSRSS_EXPUNGE_COMMAND_HISTORY, *PCSRSS_EXPUNGE_COMMAND_HISTORY;
+
+typedef struct
+{
+ UNICODE_STRING ExeName;
+ DWORD NumCommands;
+} CSRSS_SET_HISTORY_NUMBER_COMMANDS, *PCSRSS_SET_HISTORY_NUMBER_COMMANDS;
+
+typedef struct
+{
+ DWORD HistoryBufferSize;
+ DWORD NumberOfHistoryBuffers;
+ DWORD dwFlags;
+} CSRSS_GET_HISTORY_INFO, *PCSRSS_GET_HISTORY_INFO,
+ CSRSS_SET_HISTORY_INFO, *PCSRSS_SET_HISTORY_INFO;;
+
+
+typedef struct
+{
+ UINT CodePage;
+} CSRSS_GET_CONSOLE_CP, *PCSRSS_GET_CONSOLE_CP;
+
+typedef struct
+{
+ UINT CodePage;
+} CSRSS_SET_CONSOLE_CP, *PCSRSS_SET_CONSOLE_CP;
+
+typedef struct
+{
+ UINT CodePage;
+} CSRSS_GET_CONSOLE_OUTPUT_CP, *PCSRSS_GET_CONSOLE_OUTPUT_CP;
+
+typedef struct
+{
+ UINT CodePage;
+} CSRSS_SET_CONSOLE_OUTPUT_CP, *PCSRSS_SET_CONSOLE_OUTPUT_CP;
+
+#endif // __CSRCONS_H__
+
+/* EOF */
+/***************************** CSRSS Data ***********************************/
+
#ifndef __INCLUDE_CSRSS_CSRSS_H
#define __INCLUDE_CSRSS_CSRSS_H
-#include <drivers/blue/ntddblue.h>
-
#define CSR_NATIVE 0x0000
#define CSR_CONSOLE 0x0001
#define CSR_GUI 0x0002
#define CONSOLE_INPUT_MODE_VALID (0x0f)
#define CONSOLE_OUTPUT_MODE_VALID (0x03)
-/*
-typedef union _CSR_API_NUMBER
-{
- WORD Index; // CSRSS API number
- WORD Subsystem; // 0=NTDLL;1=KERNEL32;2=KERNEL32
-} CSR_API_NUMBER, *PCSR_API_NUMBER;
-*/
-
-typedef ULONG CSR_API_NUMBER;
-
-#define MAKE_CSR_API(Number, Server) \
- ((Server) << 16) + Number
#define CSR_CSRSS_SECTION_SIZE (65536)
ULONG nProcessIdsTotal;
} CSRSS_GET_PROCESS_LIST, *PCSRSS_GET_PROCESS_LIST;
-typedef struct
-{
- HANDLE ConsoleHandle;
- BOOL Unicode;
- ULONG NrCharactersToWrite;
- ULONG NrCharactersWritten;
- HANDLE UnpauseEvent;
- BYTE Buffer[0];
-} CSRSS_WRITE_CONSOLE, *PCSRSS_WRITE_CONSOLE;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- BOOL Unicode;
- WORD NrCharactersToRead;
- WORD NrCharactersRead;
- HANDLE EventHandle;
- PVOID Buffer;
- UNICODE_STRING ExeName;
- DWORD CtrlWakeupMask;
- DWORD ControlKeyState;
-} CSRSS_READ_CONSOLE, *PCSRSS_READ_CONSOLE;
-
-typedef struct
-{
- PCONTROLDISPATCHER CtrlDispatcher;
- BOOLEAN ConsoleNeeded;
- INT ShowCmd;
- HANDLE Console;
- HANDLE InputHandle;
- HANDLE OutputHandle;
-} CSRSS_ALLOC_CONSOLE, *PCSRSS_ALLOC_CONSOLE;
-
-typedef struct
-{
- ULONG Dummy;
-} CSRSS_FREE_CONSOLE, *PCSRSS_FREE_CONSOLE;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- CONSOLE_SCREEN_BUFFER_INFO Info;
-} CSRSS_SCREEN_BUFFER_INFO, *PCSRSS_SCREEN_BUFFER_INFO;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- COORD Position;
-} CSRSS_SET_CURSOR, *PCSRSS_SET_CURSOR;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- BOOL Unicode;
- union
- {
- CHAR AsciiChar;
- WCHAR UnicodeChar;
- } Char;
- COORD Position;
- WORD Length;
- ULONG NrCharactersWritten;
-} CSRSS_FILL_OUTPUT, *PCSRSS_FILL_OUTPUT;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- CHAR Attribute;
- COORD Coord;
- WORD Length;
-} CSRSS_FILL_OUTPUT_ATTRIB, *PCSRSS_FILL_OUTPUT_ATTRIB;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- BOOL Unicode;
- INPUT_RECORD Input;
- BOOL MoreEvents;
- HANDLE Event;
-} CSRSS_READ_INPUT, *PCSRSS_READ_INPUT;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- BOOL Unicode;
- WORD Length;
- COORD Coord;
- COORD EndCoord;
- ULONG NrCharactersWritten;
- CHAR String[0];
-} CSRSS_WRITE_CONSOLE_OUTPUT_CHAR, *PCSRSS_WRITE_CONSOLE_OUTPUT_CHAR;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- WORD Length;
- COORD Coord;
- COORD EndCoord;
- WORD Attribute[0];
-} CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB, *PCSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- CONSOLE_CURSOR_INFO Info;
-} CSRSS_GET_CURSOR_INFO, *PCSRSS_GET_CURSOR_INFO;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- CONSOLE_CURSOR_INFO Info;
-} CSRSS_SET_CURSOR_INFO, *PCSRSS_SET_CURSOR_INFO;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- WORD Attrib;
-} CSRSS_SET_ATTRIB, *PCSRSS_SET_ATTRIB;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- DWORD Mode;
-} CSRSS_SET_CONSOLE_MODE, *PCSRSS_SET_CONSOLE_MODE;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- DWORD ConsoleMode;
-} CSRSS_GET_CONSOLE_MODE, *PCSRSS_GET_CONSOLE_MODE;
-
-typedef struct
-{
- DWORD Access;
- DWORD ShareMode;
- BOOL Inheritable;
- HANDLE OutputHandle; /* handle to newly created screen buffer */
-} CSRSS_CREATE_SCREEN_BUFFER, *PCSRSS_CREATE_SCREEN_BUFFER;
-
-typedef struct
-{
- HANDLE OutputHandle; /* handle to screen buffer to switch to */
-} CSRSS_SET_SCREEN_BUFFER, *PCSRSS_SET_SCREEN_BUFFER;
+#include "csrcons.h"
typedef struct
{
CLIENT_ID Cid;
} CSRSS_IDENTIFY_ALERTABLE_THREAD, *PCSRSS_IDENTIFY_ALERTABLE_THREAD;
-typedef struct
-{
- DWORD Length;
- PWCHAR Title;
-} CSRSS_SET_TITLE, *PCSRSS_SET_TITLE;
-
-typedef struct
-{
- DWORD Length;
- PWCHAR Title;
-} CSRSS_GET_TITLE, *PCSRSS_GET_TITLE;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- BOOL Unicode;
- COORD BufferSize;
- COORD BufferCoord;
- SMALL_RECT WriteRegion;
- CHAR_INFO* CharInfo;
-} CSRSS_WRITE_CONSOLE_OUTPUT, *PCSRSS_WRITE_CONSOLE_OUTPUT;
-
-typedef struct
-{
- HANDLE ConsoleInput;
-} CSRSS_FLUSH_INPUT_BUFFER, *PCSRSS_FLUSH_INPUT_BUFFER;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- BOOL Unicode;
- SMALL_RECT ScrollRectangle;
- BOOLEAN UseClipRectangle;
- SMALL_RECT ClipRectangle;
- COORD DestinationOrigin;
- CHAR_INFO Fill;
-} CSRSS_SCROLL_CONSOLE_SCREEN_BUFFER, *PCSRSS_SCROLL_CONSOLE_SCREEN_BUFFER;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- BOOL Unicode;
- DWORD NumCharsToRead;
- COORD ReadCoord;
- COORD EndCoord;
- DWORD CharsRead;
- CHAR String[0];
-} CSRSS_READ_CONSOLE_OUTPUT_CHAR, *PCSRSS_READ_CONSOLE_OUTPUT_CHAR;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- DWORD NumAttrsToRead;
- COORD ReadCoord;
- COORD EndCoord;
- WORD Attribute[0];
-} CSRSS_READ_CONSOLE_OUTPUT_ATTRIB, *PCSRSS_READ_CONSOLE_OUTPUT_ATTRIB;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- DWORD NumInputEvents;
-} CSRSS_GET_NUM_INPUT_EVENTS, *PCSRSS_GET_NUM_INPUT_EVENTS;
-
typedef struct
{
HANDLE ProcessId;
DWORD Flags;
} CSRSS_GET_SHUTDOWN_PARAMETERS, *PCSRSS_GET_SHUTDOWN_PARAMETERS;
-typedef struct
-{
- HANDLE ConsoleHandle;
- BOOL Unicode;
- DWORD Length;
- INPUT_RECORD* InputRecord;
-} CSRSS_PEEK_CONSOLE_INPUT, *PCSRSS_PEEK_CONSOLE_INPUT;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- BOOL Unicode;
- COORD BufferSize;
- COORD BufferCoord;
- SMALL_RECT ReadRegion;
- CHAR_INFO* CharInfo;
-} CSRSS_READ_CONSOLE_OUTPUT, *PCSRSS_READ_CONSOLE_OUTPUT;
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- BOOL Unicode;
- DWORD Length;
- INPUT_RECORD* InputRecord;
-} CSRSS_WRITE_CONSOLE_INPUT, *PCSRSS_WRITE_CONSOLE_INPUT;
-
-typedef struct
-{
- DWORD Access;
- BOOL Inheritable;
- HANDLE Handle;
- DWORD ShareMode;
-} CSRSS_GET_INPUT_HANDLE, *PCSRSS_GET_INPUT_HANDLE,
- CSRSS_GET_OUTPUT_HANDLE, *PCSRSS_GET_OUTPUT_HANDLE;
-
typedef struct
{
HANDLE Handle;
DWORD Options;
} CSRSS_DUPLICATE_HANDLE, *PCSRSS_DUPLICATE_HANDLE;
-#define CONSOLE_HARDWARE_STATE_GET 0
-#define CONSOLE_HARDWARE_STATE_SET 1
-
-#define CONSOLE_HARDWARE_STATE_GDI_MANAGED 0
-#define CONSOLE_HARDWARE_STATE_DIRECT 1
-
-typedef struct
-{
- HANDLE ConsoleHandle;
- DWORD SetGet; /* 0=get; 1=set */
- DWORD State;
-} CSRSS_SETGET_CONSOLE_HW_STATE, *PCSRSS_SETGET_CONSOLE_HW_STATE;
-
-typedef struct
-{
- HWND WindowHandle;
-} CSRSS_GET_CONSOLE_WINDOW, *PCSRSS_GET_CONSOLE_WINDOW;
-
-typedef struct
-{
- HICON WindowIcon;
-} CSRSS_SET_CONSOLE_ICON, *PCSRSS_SET_CONSOLE_ICON;
-
typedef struct
{
HDESK DesktopHandle;
BOOL Register;
} CSRSS_REGISTER_LOGON_PROCESS, *PCSRSS_REGISTER_LOGON_PROCESS;
-typedef struct
-{
- UINT CodePage;
-} CSRSS_GET_CONSOLE_CP, *PCSRSS_GET_CONSOLE_CP;
-
-typedef struct
-{
- UINT CodePage;
-} CSRSS_SET_CONSOLE_CP, *PCSRSS_SET_CONSOLE_CP;
-
-typedef struct
-{
- UINT CodePage;
-} CSRSS_GET_CONSOLE_OUTPUT_CP, *PCSRSS_GET_CONSOLE_OUTPUT_CP;
-
-typedef struct
-{
- UINT CodePage;
-} CSRSS_SET_CONSOLE_OUTPUT_CP, *PCSRSS_SET_CONSOLE_OUTPUT_CP;
-
typedef struct
{
HANDLE InputWaitHandle;
} CSRSS_GET_INPUT_WAIT_HANDLE, *PCSRSS_GET_INPUT_WAIT_HANDLE;
-typedef struct
-{
- ULONG SourceLength;
- ULONG ExeLength;
- ULONG TargetLength;
-} CSRSS_ADD_CONSOLE_ALIAS, *PCSRSS_ADD_CONSOLE_ALIAS;
-
-typedef struct
-{
- ULONG SourceLength;
- ULONG ExeLength;
- ULONG BytesWritten;
- ULONG TargetBufferLength;
- PVOID TargetBuffer;
-} CSRSS_GET_CONSOLE_ALIAS, *PCSRSS_GET_CONSOLE_ALIAS;
-
-typedef struct
-{
- LPWSTR lpExeName;
- DWORD BytesWritten;
- DWORD AliasBufferLength;
- LPWSTR AliasBuffer;
-} CSRSS_GET_ALL_CONSOLE_ALIASES, *PCSRSS_GET_ALL_CONSOLE_ALIAS;
-
-typedef struct
-{
- LPWSTR lpExeName;
- DWORD Length;
-} CSRSS_GET_ALL_CONSOLE_ALIASES_LENGTH, *PCSRSS_GET_ALL_CONSOLE_ALIASES_LENGTH;
-
-typedef struct
-{
- DWORD BytesWritten;
- DWORD Length;
- LPWSTR ExeNames;
-} CSRSS_GET_CONSOLE_ALIASES_EXES, *PCSRSS_GET_CONSOLE_ALIASES_EXES;
-
-typedef struct
-{
- DWORD Length;
-} CSRSS_GET_CONSOLE_ALIASES_EXES_LENGTH, *PCSRSS_GET_CONSOLE_ALIASES_EXES_LENGTH;
-
-typedef struct
-{
- DWORD Event;
- DWORD ProcessGroup;
-} CSRSS_GENERATE_CTRL_EVENT, *PCSRSS_GENERATE_CTRL_EVENT;
-
-typedef struct
-{
- HANDLE OutputHandle;
- COORD Size;
-} CSRSS_SET_SCREEN_BUFFER_SIZE, *PCSRSS_SET_SCREEN_BUFFER_SIZE;
-
-typedef struct
-{
- CONSOLE_SELECTION_INFO Info;
-} CSRSS_GET_CONSOLE_SELECTION_INFO, *PCSRSS_GET_CONSOLE_SELECTION_INFO;
-
-typedef struct
-{
- UNICODE_STRING ExeName;
- DWORD Length;
-} CSRSS_GET_COMMAND_HISTORY_LENGTH, *PCSRSS_GET_COMMAND_HISTORY_LENGTH;
-
-typedef struct
-{
- UNICODE_STRING ExeName;
- PWCHAR History;
- DWORD Length;
-} CSRSS_GET_COMMAND_HISTORY, *PCSRSS_GET_COMMAND_HISTORY;
-
-typedef struct
-{
- UNICODE_STRING ExeName;
-} CSRSS_EXPUNGE_COMMAND_HISTORY, *PCSRSS_EXPUNGE_COMMAND_HISTORY;
-
-typedef struct
-{
- UNICODE_STRING ExeName;
- DWORD NumCommands;
-} CSRSS_SET_HISTORY_NUMBER_COMMANDS, *PCSRSS_SET_HISTORY_NUMBER_COMMANDS;
-
-typedef struct
-{
- DWORD HistoryBufferSize;
- DWORD NumberOfHistoryBuffers;
- DWORD dwFlags;
-} CSRSS_GET_HISTORY_INFO, *PCSRSS_GET_HISTORY_INFO,
- CSRSS_SET_HISTORY_INFO, *PCSRSS_SET_HISTORY_INFO;;
-
typedef struct
{
UINT UniqueID;
#define CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR (LPC_MAX_DATA_LENGTH - CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_CHAR))
#define CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB (LPC_MAX_DATA_LENGTH - CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_ATTRIB))
-#define CREATE_PROCESS (0x0)
-#define TERMINATE_PROCESS (0x1)
-#define WRITE_CONSOLE (0x2)
-#define READ_CONSOLE (0x3)
-#define ALLOC_CONSOLE (0x4)
-#define FREE_CONSOLE (0x5)
-#define CONNECT_PROCESS (0x6)
-#define SCREEN_BUFFER_INFO (0x7)
-#define SET_CURSOR (0x8)
-#define FILL_OUTPUT (0x9)
-#define READ_INPUT (0xA)
-#define WRITE_CONSOLE_OUTPUT_CHAR (0xB)
-#define WRITE_CONSOLE_OUTPUT_ATTRIB (0xC)
-#define FILL_OUTPUT_ATTRIB (0xD)
-#define GET_CURSOR_INFO (0xE)
-#define SET_CURSOR_INFO (0xF)
-#define SET_ATTRIB (0x10)
-#define GET_CONSOLE_MODE (0x11)
-#define SET_CONSOLE_MODE (0x12)
-#define CREATE_SCREEN_BUFFER (0x13)
-#define SET_SCREEN_BUFFER (0x14)
-#define SET_TITLE (0x15)
-#define GET_TITLE (0x16)
-#define WRITE_CONSOLE_OUTPUT (0x17)
-#define FLUSH_INPUT_BUFFER (0x18)
-#define SCROLL_CONSOLE_SCREEN_BUFFER (0x19)
-#define READ_CONSOLE_OUTPUT_CHAR (0x1A)
-#define READ_CONSOLE_OUTPUT_ATTRIB (0x1B)
-#define GET_NUM_INPUT_EVENTS (0x1C)
-#define REGISTER_SERVICES_PROCESS (0x1D)
-#define EXIT_REACTOS (0x1E)
-#define GET_SHUTDOWN_PARAMETERS (0x1F)
-#define SET_SHUTDOWN_PARAMETERS (0x20)
-#define PEEK_CONSOLE_INPUT (0x21)
-#define READ_CONSOLE_OUTPUT (0x22)
-#define WRITE_CONSOLE_INPUT (0x23)
-#define GET_INPUT_HANDLE (0x24)
-#define GET_OUTPUT_HANDLE (0x25)
-#define CLOSE_HANDLE (0x26)
-#define VERIFY_HANDLE (0x27)
-#define DUPLICATE_HANDLE (0x28)
-#define SETGET_CONSOLE_HW_STATE (0x29)
-#define GET_CONSOLE_WINDOW (0x2A)
-#define CREATE_DESKTOP (0x2B)
-#define SHOW_DESKTOP (0x2C)
-#define HIDE_DESKTOP (0x2D)
-#define SET_CONSOLE_ICON (0x2E)
-#define SET_LOGON_NOTIFY_WINDOW (0x2F)
-#define REGISTER_LOGON_PROCESS (0x30)
-#define GET_CONSOLE_CP (0x31)
-#define SET_CONSOLE_CP (0x32)
-#define GET_CONSOLE_OUTPUT_CP (0x33)
-#define SET_CONSOLE_OUTPUT_CP (0x34)
-#define GET_INPUT_WAIT_HANDLE (0x35)
-#define GET_PROCESS_LIST (0x36)
-#define START_SCREEN_SAVER (0x37)
-#define ADD_CONSOLE_ALIAS (0x38)
-#define GET_CONSOLE_ALIAS (0x39)
+#define CREATE_PROCESS (0x0)
+#define TERMINATE_PROCESS (0x1)
+#define WRITE_CONSOLE (0x2)
+#define READ_CONSOLE (0x3)
+#define ALLOC_CONSOLE (0x4)
+#define FREE_CONSOLE (0x5)
+#define CONNECT_PROCESS (0x6)
+#define SCREEN_BUFFER_INFO (0x7)
+#define SET_CURSOR (0x8)
+#define FILL_OUTPUT (0x9)
+#define READ_INPUT (0xA)
+#define WRITE_CONSOLE_OUTPUT_CHAR (0xB)
+#define WRITE_CONSOLE_OUTPUT_ATTRIB (0xC)
+#define FILL_OUTPUT_ATTRIB (0xD)
+#define GET_CURSOR_INFO (0xE)
+#define SET_CURSOR_INFO (0xF)
+#define SET_ATTRIB (0x10)
+#define GET_CONSOLE_MODE (0x11)
+#define SET_CONSOLE_MODE (0x12)
+#define CREATE_SCREEN_BUFFER (0x13)
+#define SET_SCREEN_BUFFER (0x14)
+#define SET_TITLE (0x15)
+#define GET_TITLE (0x16)
+#define WRITE_CONSOLE_OUTPUT (0x17)
+#define FLUSH_INPUT_BUFFER (0x18)
+#define SCROLL_CONSOLE_SCREEN_BUFFER (0x19)
+#define READ_CONSOLE_OUTPUT_CHAR (0x1A)
+#define READ_CONSOLE_OUTPUT_ATTRIB (0x1B)
+#define GET_NUM_INPUT_EVENTS (0x1C)
+#define REGISTER_SERVICES_PROCESS (0x1D)
+#define EXIT_REACTOS (0x1E)
+#define GET_SHUTDOWN_PARAMETERS (0x1F)
+#define SET_SHUTDOWN_PARAMETERS (0x20)
+#define PEEK_CONSOLE_INPUT (0x21)
+#define READ_CONSOLE_OUTPUT (0x22)
+#define WRITE_CONSOLE_INPUT (0x23)
+#define GET_INPUT_HANDLE (0x24)
+#define GET_OUTPUT_HANDLE (0x25)
+#define CLOSE_HANDLE (0x26)
+#define VERIFY_HANDLE (0x27)
+#define DUPLICATE_HANDLE (0x28)
+#define SETGET_CONSOLE_HW_STATE (0x29)
+#define GET_CONSOLE_WINDOW (0x2A)
+#define CREATE_DESKTOP (0x2B)
+#define SHOW_DESKTOP (0x2C)
+#define HIDE_DESKTOP (0x2D)
+#define SET_CONSOLE_ICON (0x2E)
+#define SET_LOGON_NOTIFY_WINDOW (0x2F)
+#define REGISTER_LOGON_PROCESS (0x30)
+#define GET_CONSOLE_CP (0x31)
+#define SET_CONSOLE_CP (0x32)
+#define GET_CONSOLE_OUTPUT_CP (0x33)
+#define SET_CONSOLE_OUTPUT_CP (0x34)
+#define GET_INPUT_WAIT_HANDLE (0x35)
+#define GET_PROCESS_LIST (0x36)
+#define START_SCREEN_SAVER (0x37)
+#define ADD_CONSOLE_ALIAS (0x38)
+#define GET_CONSOLE_ALIAS (0x39)
#define GET_ALL_CONSOLE_ALIASES (0x3A)
-#define GET_ALL_CONSOLE_ALIASES_LENGTH (0x3B)
-#define GET_CONSOLE_ALIASES_EXES (0x3C)
+#define GET_ALL_CONSOLE_ALIASES_LENGTH (0x3B)
+#define GET_CONSOLE_ALIASES_EXES (0x3C)
#define GET_CONSOLE_ALIASES_EXES_LENGTH (0x3D)
-#define GENERATE_CTRL_EVENT (0x3E)
-#define CREATE_THREAD (0x3F)
-#define SET_SCREEN_BUFFER_SIZE (0x40)
-#define GET_CONSOLE_SELECTION_INFO (0x41)
-#define GET_COMMAND_HISTORY_LENGTH (0x42)
-#define GET_COMMAND_HISTORY (0x43)
-#define EXPUNGE_COMMAND_HISTORY (0x44)
-#define SET_HISTORY_NUMBER_COMMANDS (0x45)
-#define GET_HISTORY_INFO (0x46)
-#define SET_HISTORY_INFO (0x47)
-#define GET_TEMP_FILE (0x48)
-#define DEFINE_DOS_DEVICE (0X49)
-#define SOUND_SENTRY (0x50)
-#define UPDATE_VDM_ENTRY (0x51)
-#define GET_VDM_EXIT_CODE (0x52)
-#define CHECK_VDM (0x53)
-
-/* Keep in sync with definition below. */
-#define CSRSS_HEADER_SIZE (sizeof(PORT_MESSAGE) + sizeof(ULONG) + sizeof(NTSTATUS))
-
-typedef struct _CSR_API_MESSAGE
-{
- PORT_MESSAGE Header;
- PVOID CsrCaptureData;
- ULONG Type;
- NTSTATUS Status;
- union
- {
- CSRSS_CREATE_PROCESS CreateProcessRequest;
- CSRSS_CREATE_THREAD CreateThreadRequest;
- CSRSS_TERMINATE_PROCESS TerminateProcessRequest;
- CSRSS_CONNECT_PROCESS ConnectRequest;
- CSRSS_WRITE_CONSOLE WriteConsoleRequest;
- CSRSS_READ_CONSOLE ReadConsoleRequest;
- CSRSS_ALLOC_CONSOLE AllocConsoleRequest;
- CSRSS_SCREEN_BUFFER_INFO ScreenBufferInfoRequest;
- CSRSS_SET_CURSOR SetCursorRequest;
- CSRSS_FILL_OUTPUT FillOutputRequest;
- CSRSS_READ_INPUT ReadInputRequest;
- CSRSS_WRITE_CONSOLE_OUTPUT_CHAR WriteConsoleOutputCharRequest;
- CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB WriteConsoleOutputAttribRequest;
- CSRSS_FILL_OUTPUT_ATTRIB FillOutputAttribRequest;
- CSRSS_SET_CURSOR_INFO SetCursorInfoRequest;
- CSRSS_GET_CURSOR_INFO GetCursorInfoRequest;
- CSRSS_SET_ATTRIB SetAttribRequest;
- CSRSS_SET_CONSOLE_MODE SetConsoleModeRequest;
- CSRSS_GET_CONSOLE_MODE GetConsoleModeRequest;
- CSRSS_CREATE_SCREEN_BUFFER CreateScreenBufferRequest;
- CSRSS_SET_SCREEN_BUFFER SetScreenBufferRequest;
- CSRSS_SET_TITLE SetTitleRequest;
- CSRSS_GET_TITLE GetTitleRequest;
- CSRSS_WRITE_CONSOLE_OUTPUT WriteConsoleOutputRequest;
- CSRSS_FLUSH_INPUT_BUFFER FlushInputBufferRequest;
- CSRSS_SCROLL_CONSOLE_SCREEN_BUFFER ScrollConsoleScreenBufferRequest;
- CSRSS_READ_CONSOLE_OUTPUT_CHAR ReadConsoleOutputCharRequest;
- CSRSS_READ_CONSOLE_OUTPUT_ATTRIB ReadConsoleOutputAttribRequest;
- CSRSS_GET_NUM_INPUT_EVENTS GetNumInputEventsRequest;
- CSRSS_REGISTER_SERVICES_PROCESS RegisterServicesProcessRequest;
- CSRSS_EXIT_REACTOS ExitReactosRequest;
- CSRSS_SET_SHUTDOWN_PARAMETERS SetShutdownParametersRequest;
- CSRSS_GET_SHUTDOWN_PARAMETERS GetShutdownParametersRequest;
- CSRSS_PEEK_CONSOLE_INPUT PeekConsoleInputRequest;
- CSRSS_READ_CONSOLE_OUTPUT ReadConsoleOutputRequest;
- CSRSS_WRITE_CONSOLE_INPUT WriteConsoleInputRequest;
- CSRSS_GET_INPUT_HANDLE GetInputHandleRequest;
- CSRSS_GET_OUTPUT_HANDLE GetOutputHandleRequest;
- CSRSS_CLOSE_HANDLE CloseHandleRequest;
- CSRSS_VERIFY_HANDLE VerifyHandleRequest;
- CSRSS_DUPLICATE_HANDLE DuplicateHandleRequest;
- CSRSS_SETGET_CONSOLE_HW_STATE ConsoleHardwareStateRequest;
- CSRSS_GET_CONSOLE_WINDOW GetConsoleWindowRequest;
- CSRSS_CREATE_DESKTOP CreateDesktopRequest;
- CSRSS_SHOW_DESKTOP ShowDesktopRequest;
- CSRSS_HIDE_DESKTOP HideDesktopRequest;
- CSRSS_SET_CONSOLE_ICON SetConsoleIconRequest;
- CSRSS_SET_LOGON_NOTIFY_WINDOW SetLogonNotifyWindowRequest;
- CSRSS_REGISTER_LOGON_PROCESS RegisterLogonProcessRequest;
- CSRSS_GET_CONSOLE_CP GetConsoleCodePage;
- CSRSS_SET_CONSOLE_CP SetConsoleCodePage;
- CSRSS_GET_CONSOLE_OUTPUT_CP GetConsoleOutputCodePage;
- CSRSS_SET_CONSOLE_OUTPUT_CP SetConsoleOutputCodePage;
- CSRSS_GET_INPUT_WAIT_HANDLE GetConsoleInputWaitHandle;
- CSRSS_GET_PROCESS_LIST GetProcessListRequest;
- CSRSS_ADD_CONSOLE_ALIAS AddConsoleAlias;
- CSRSS_GET_CONSOLE_ALIAS GetConsoleAlias;
- CSRSS_GET_ALL_CONSOLE_ALIASES GetAllConsoleAlias;
- CSRSS_GET_ALL_CONSOLE_ALIASES_LENGTH GetAllConsoleAliasesLength;
- CSRSS_GET_CONSOLE_ALIASES_EXES GetConsoleAliasesExes;
- CSRSS_GET_CONSOLE_ALIASES_EXES_LENGTH GetConsoleAliasesExesLength;
- CSRSS_GENERATE_CTRL_EVENT GenerateCtrlEvent;
- CSRSS_SET_SCREEN_BUFFER_SIZE SetScreenBufferSize;
- CSRSS_GET_CONSOLE_SELECTION_INFO GetConsoleSelectionInfo;
- CSRSS_GET_COMMAND_HISTORY_LENGTH GetCommandHistoryLength;
- CSRSS_GET_COMMAND_HISTORY GetCommandHistory;
- CSRSS_EXPUNGE_COMMAND_HISTORY ExpungeCommandHistory;
- CSRSS_SET_HISTORY_NUMBER_COMMANDS SetHistoryNumberCommands;
- CSRSS_GET_HISTORY_INFO GetHistoryInfo;
- CSRSS_SET_HISTORY_INFO SetHistoryInfo;
- CSRSS_GET_TEMP_FILE GetTempFile;
- CSRSS_DEFINE_DOS_DEVICE DefineDosDeviceRequest;
- CSRSS_SOUND_SENTRY SoundSentryRequest;
- CSRSS_UPDATE_VDM_ENTRY UpdateVdmEntry;
- CSRSS_GET_VDM_EXIT_CODE GetVdmExitCode;
- CSRSS_CHECK_VDM CheckVdm;
- } Data;
-} CSR_API_MESSAGE, *PCSR_API_MESSAGE;
+#define GENERATE_CTRL_EVENT (0x3E)
+#define CREATE_THREAD (0x3F)
+#define SET_SCREEN_BUFFER_SIZE (0x40)
+#define GET_CONSOLE_SELECTION_INFO (0x41)
+#define GET_COMMAND_HISTORY_LENGTH (0x42)
+#define GET_COMMAND_HISTORY (0x43)
+#define EXPUNGE_COMMAND_HISTORY (0x44)
+#define SET_HISTORY_NUMBER_COMMANDS (0x45)
+#define GET_HISTORY_INFO (0x46)
+#define SET_HISTORY_INFO (0x47)
+#define GET_TEMP_FILE (0x48)
+#define DEFINE_DOS_DEVICE (0x49)
+#define SOUND_SENTRY (0x50)
+#define UPDATE_VDM_ENTRY (0x51)
+#define GET_VDM_EXIT_CODE (0x52)
+#define CHECK_VDM (0x53)
+
typedef struct _NLS_USER_INFO
{
WCHAR sLocaleName[85];
LCID UserLocaleId;
LUID InteractiveUserLuid;
- CHAR InteractiveUserSid[68]; // SECURITY_MAX_SID_SIZE to make ros happy
+ CHAR InteractiveUserSid[68]; // SECURITY_MAX_SID_SIZE to make ROS happy
ULONG ulCacheUpdateCount;
} NLS_USER_INFO, *PNLS_USER_INFO;
/* Types used in the new CSR. Temporarly here for proper compile of NTDLL */
-#define CSR_SRV_SERVER 0
-
+// Not used at the moment...
typedef enum _CSR_SRV_API_NUMBER
{
CsrpClientConnect,
CsrpMaxApiNumber
} CSR_SRV_API_NUMBER, *PCSR_SRV_API_NUMBER;
-#define CSR_MAKE_OPCODE(s,m) ((s) << 16) | (m)
-
-typedef struct _CSR_CONNECTION_INFO
-{
- ULONG Version;
- ULONG Unknown;
- HANDLE ObjectDirectory;
- PVOID SharedSectionBase;
- PVOID SharedSectionHeap;
- PVOID SharedSectionData;
- ULONG DebugFlags;
- ULONG Unknown2[3];
- HANDLE ProcessId;
-} CSR_CONNECTION_INFO, *PCSR_CONNECTION_INFO;
-
-typedef struct _CSR_CLIENT_CONNECT
-{
- ULONG ServerId;
- PVOID ConnectionInfo;
- ULONG ConnectionInfoSize;
-} CSR_CLIENT_CONNECT, *PCSR_CLIENT_CONNECT;
-
-typedef struct _CSR_IDENTIFY_ALTERTABLE_THREAD
-{
- CLIENT_ID Cid;
-} CSR_IDENTIFY_ALTERTABLE_THREAD, *PCSR_IDENTIFY_ALTERTABLE_THREAD;
-
-typedef struct _CSR_SET_PRIORITY_CLASS
-{
- HANDLE hProcess;
- ULONG PriorityClass;
-} CSR_SET_PRIORITY_CLASS, *PCSR_SET_PRIORITY_CLASS;
-
-typedef struct _CSR_API_MESSAGE2
-{
- PORT_MESSAGE Header;
- union
- {
- CSR_CONNECTION_INFO ConnectionInfo;
- struct
- {
- PVOID CsrCaptureData;
- CSR_API_NUMBER Opcode;
- ULONG Status;
- ULONG Reserved;
- union
- {
- CSR_CLIENT_CONNECT ClientConnect;
- CSR_SET_PRIORITY_CLASS SetPriorityClass;
- CSR_IDENTIFY_ALTERTABLE_THREAD IdentifyAlertableThread;
- };
- };
- };
-} CSR_API_MESSAGE2, *PCSR_API_MESSAGE2;
-
-typedef struct _CSR_CAPTURE_BUFFER
-{
- ULONG Size;
- struct _CSR_CAPTURE_BUFFER *PreviousCaptureBuffer;
- ULONG PointerCount;
- ULONG_PTR BufferEnd;
- ULONG_PTR PointerArray[1];
-} CSR_CAPTURE_BUFFER, *PCSR_CAPTURE_BUFFER;
-
#endif /* __INCLUDE_CSRSS_CSRSS_H */
--- /dev/null
+/*
+ * PROJECT: ReactOS Native Headers
+ * FILE: include/subsys/csrss/msg.h
+ * PURPOSE: Public Definitions for communication
+ * between CSR Clients and Servers.
+ * PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
+ * Hermes Belusca-Maito (hermes.belusca@sfr.fr)
+ */
+
+#ifndef _CSRMSG_H
+#define _CSRMSG_H
+
+typedef struct _CSR_CONNECTION_INFO
+{
+ ULONG Version;
+ ULONG Unknown;
+ HANDLE ObjectDirectory;
+ PVOID SharedSectionBase;
+ PVOID SharedSectionHeap;
+ PVOID SharedSectionData;
+ ULONG DebugFlags;
+ ULONG Unknown2[3];
+ HANDLE ProcessId;
+} CSR_CONNECTION_INFO, *PCSR_CONNECTION_INFO;
+
+typedef struct _CSR_IDENTIFY_ALTERTABLE_THREAD
+{
+ CLIENT_ID Cid;
+} CSR_IDENTIFY_ALTERTABLE_THREAD, *PCSR_IDENTIFY_ALTERTABLE_THREAD;
+
+typedef struct _CSR_SET_PRIORITY_CLASS
+{
+ HANDLE hProcess;
+ ULONG PriorityClass;
+} CSR_SET_PRIORITY_CLASS, *PCSR_SET_PRIORITY_CLASS;
+
+typedef struct _CSR_CLIENT_CONNECT
+{
+ ULONG ServerId;
+ PVOID ConnectionInfo;
+ ULONG ConnectionInfoSize;
+} CSR_CLIENT_CONNECT, *PCSR_CLIENT_CONNECT;
+
+typedef struct _CSR_CAPTURE_BUFFER
+{
+ ULONG Size;
+ struct _CSR_CAPTURE_BUFFER *PreviousCaptureBuffer;
+ ULONG PointerCount;
+ ULONG_PTR BufferEnd;
+ ULONG_PTR PointerArray[1];
+} CSR_CAPTURE_BUFFER, *PCSR_CAPTURE_BUFFER;
+
+/*
+typedef union _CSR_API_NUMBER
+{
+ WORD Index;
+ WORD Subsystem;
+} CSR_API_NUMBER, *PCSR_API_NUMBER;
+*/
+typedef ULONG CSR_API_NUMBER;
+
+#include "csrss.h" // remove it when the data structures are not used anymore.
+
+/* Keep in sync with definition below. */
+// #define CSRSS_HEADER_SIZE (sizeof(PORT_MESSAGE) + sizeof(ULONG) + sizeof(NTSTATUS))
+
+typedef struct _CSR_API_MESSAGE
+{
+ PORT_MESSAGE Header;
+ union
+ {
+ CSR_CONNECTION_INFO ConnectionInfo;
+ struct
+ {
+ PCSR_CAPTURE_BUFFER CsrCaptureData;
+ CSR_API_NUMBER ApiNumber;
+ ULONG Status;
+ ULONG Reserved;
+ union
+ {
+ CSR_CLIENT_CONNECT CsrClientConnect;
+
+ CSR_SET_PRIORITY_CLASS SetPriorityClass;
+ CSR_IDENTIFY_ALTERTABLE_THREAD IdentifyAlertableThread;
+
+ /*** Temporary ***/
+#if 1
+ CSRSS_CREATE_PROCESS CreateProcessRequest;
+ CSRSS_CREATE_THREAD CreateThreadRequest;
+ CSRSS_TERMINATE_PROCESS TerminateProcessRequest;
+ CSRSS_CONNECT_PROCESS ConnectRequest;
+ CSRSS_WRITE_CONSOLE WriteConsoleRequest;
+ CSRSS_READ_CONSOLE ReadConsoleRequest;
+ CSRSS_ALLOC_CONSOLE AllocConsoleRequest;
+ CSRSS_SCREEN_BUFFER_INFO ScreenBufferInfoRequest;
+ CSRSS_SET_CURSOR SetCursorRequest;
+ CSRSS_FILL_OUTPUT FillOutputRequest;
+ CSRSS_READ_INPUT ReadInputRequest;
+ CSRSS_WRITE_CONSOLE_OUTPUT_CHAR WriteConsoleOutputCharRequest;
+ CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB WriteConsoleOutputAttribRequest;
+ CSRSS_FILL_OUTPUT_ATTRIB FillOutputAttribRequest;
+ CSRSS_SET_CURSOR_INFO SetCursorInfoRequest;
+ CSRSS_GET_CURSOR_INFO GetCursorInfoRequest;
+ CSRSS_SET_ATTRIB SetAttribRequest;
+ CSRSS_SET_CONSOLE_MODE SetConsoleModeRequest;
+ CSRSS_GET_CONSOLE_MODE GetConsoleModeRequest;
+ CSRSS_CREATE_SCREEN_BUFFER CreateScreenBufferRequest;
+ CSRSS_SET_SCREEN_BUFFER SetScreenBufferRequest;
+ CSRSS_SET_TITLE SetTitleRequest;
+ CSRSS_GET_TITLE GetTitleRequest;
+ CSRSS_WRITE_CONSOLE_OUTPUT WriteConsoleOutputRequest;
+ CSRSS_FLUSH_INPUT_BUFFER FlushInputBufferRequest;
+ CSRSS_SCROLL_CONSOLE_SCREEN_BUFFER ScrollConsoleScreenBufferRequest;
+ CSRSS_READ_CONSOLE_OUTPUT_CHAR ReadConsoleOutputCharRequest;
+ CSRSS_READ_CONSOLE_OUTPUT_ATTRIB ReadConsoleOutputAttribRequest;
+ CSRSS_GET_NUM_INPUT_EVENTS GetNumInputEventsRequest;
+ CSRSS_REGISTER_SERVICES_PROCESS RegisterServicesProcessRequest;
+ CSRSS_EXIT_REACTOS ExitReactosRequest;
+ CSRSS_SET_SHUTDOWN_PARAMETERS SetShutdownParametersRequest;
+ CSRSS_GET_SHUTDOWN_PARAMETERS GetShutdownParametersRequest;
+ CSRSS_PEEK_CONSOLE_INPUT PeekConsoleInputRequest;
+ CSRSS_READ_CONSOLE_OUTPUT ReadConsoleOutputRequest;
+ CSRSS_WRITE_CONSOLE_INPUT WriteConsoleInputRequest;
+ CSRSS_GET_INPUT_HANDLE GetInputHandleRequest;
+ CSRSS_GET_OUTPUT_HANDLE GetOutputHandleRequest;
+ CSRSS_CLOSE_HANDLE CloseHandleRequest;
+ CSRSS_VERIFY_HANDLE VerifyHandleRequest;
+ CSRSS_DUPLICATE_HANDLE DuplicateHandleRequest;
+ CSRSS_SETGET_CONSOLE_HW_STATE ConsoleHardwareStateRequest;
+ CSRSS_GET_CONSOLE_WINDOW GetConsoleWindowRequest;
+ CSRSS_CREATE_DESKTOP CreateDesktopRequest;
+ CSRSS_SHOW_DESKTOP ShowDesktopRequest;
+ CSRSS_HIDE_DESKTOP HideDesktopRequest;
+ CSRSS_SET_CONSOLE_ICON SetConsoleIconRequest;
+ CSRSS_SET_LOGON_NOTIFY_WINDOW SetLogonNotifyWindowRequest;
+ CSRSS_REGISTER_LOGON_PROCESS RegisterLogonProcessRequest;
+ CSRSS_GET_CONSOLE_CP GetConsoleCodePage;
+ CSRSS_SET_CONSOLE_CP SetConsoleCodePage;
+ CSRSS_GET_CONSOLE_OUTPUT_CP GetConsoleOutputCodePage;
+ CSRSS_SET_CONSOLE_OUTPUT_CP SetConsoleOutputCodePage;
+ CSRSS_GET_INPUT_WAIT_HANDLE GetConsoleInputWaitHandle;
+ CSRSS_GET_PROCESS_LIST GetProcessListRequest;
+ CSRSS_ADD_CONSOLE_ALIAS AddConsoleAlias;
+ CSRSS_GET_CONSOLE_ALIAS GetConsoleAlias;
+ CSRSS_GET_ALL_CONSOLE_ALIASES GetAllConsoleAlias;
+ CSRSS_GET_ALL_CONSOLE_ALIASES_LENGTH GetAllConsoleAliasesLength;
+ CSRSS_GET_CONSOLE_ALIASES_EXES GetConsoleAliasesExes;
+ CSRSS_GET_CONSOLE_ALIASES_EXES_LENGTH GetConsoleAliasesExesLength;
+ CSRSS_GENERATE_CTRL_EVENT GenerateCtrlEvent;
+ CSRSS_SET_SCREEN_BUFFER_SIZE SetScreenBufferSize;
+ CSRSS_GET_CONSOLE_SELECTION_INFO GetConsoleSelectionInfo;
+ CSRSS_GET_COMMAND_HISTORY_LENGTH GetCommandHistoryLength;
+ CSRSS_GET_COMMAND_HISTORY GetCommandHistory;
+ CSRSS_EXPUNGE_COMMAND_HISTORY ExpungeCommandHistory;
+ CSRSS_SET_HISTORY_NUMBER_COMMANDS SetHistoryNumberCommands;
+ CSRSS_GET_HISTORY_INFO GetHistoryInfo;
+ CSRSS_SET_HISTORY_INFO SetHistoryInfo;
+ CSRSS_GET_TEMP_FILE GetTempFile;
+ CSRSS_DEFINE_DOS_DEVICE DefineDosDeviceRequest;
+ CSRSS_SOUND_SENTRY SoundSentryRequest;
+ CSRSS_UPDATE_VDM_ENTRY UpdateVdmEntry;
+ CSRSS_GET_VDM_EXIT_CODE GetVdmExitCode;
+ CSRSS_CHECK_VDM CheckVdm;
+#endif
+ /*****************/
+ } Data;
+ };
+ };
+} CSR_API_MESSAGE, *PCSR_API_MESSAGE;
+
+/*** old ***
+typedef struct _CSR_API_MESSAGE
+{
+ PORT_MESSAGE Header;
+ PVOID CsrCaptureData;
+ ULONG Type;
+ NTSTATUS Status;
+ union
+ {
+ CSRSS_CREATE_PROCESS CreateProcessRequest;
+ CSRSS_CREATE_THREAD CreateThreadRequest;
+ CSRSS_TERMINATE_PROCESS TerminateProcessRequest;
+ CSRSS_CONNECT_PROCESS ConnectRequest;
+
+ . . . . . . . . . . . . . . .
+
+ CSRSS_GET_VDM_EXIT_CODE GetVdmExitCode;
+ CSRSS_CHECK_VDM CheckVdm;
+ } Data;
+} CSR_API_MESSAGE, *PCSR_API_MESSAGE;
+
+***/
+
+
+
+
+#define CSR_PORT_NAME L"ApiPort"
+
+/**** move these defines elsewhere ****/
+
+#define CSR_SRV_SERVER 0
+#define CSR_SERVER_DLL_MAX 4
+
+/**************************************/
+
+
+
+#define CSR_CREATE_API_NUMBER(ServerId, ApiId) \
+ (CSR_API_NUMBER)(((ServerId) << 16) | (ApiId))
+
+#define CSR_API_NUMBER_TO_SERVER_ID(ApiNumber) \
+ (ULONG)((ULONG)(ApiNumber) >> 16)
+
+#define CSR_API_NUMBER_TO_API_ID(ApiNumber) \
+ (ULONG)((ULONG)(ApiNumber) & 0xFFFF)
+
+#endif // _CSRMSG_H
+
+/* EOF */
/*
* PROJECT: ReactOS Native Headers
- * FILE: include/subsys/csr/server.h
+ * FILE: include/subsys/csrss/server.h
* PURPOSE: Public Definitions for CSR Servers
- * PROGRAMMER: Alex Ionescu (alex@relsoft.net)
+ * PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
+ * Hermes Belusca-Maito (hermes.belusca@sfr.fr)
*/
+
#ifndef _CSRSERVER_H
#define _CSRSERVER_H
#pragma warning (disable:4201)
#endif
-/* DEPENDENCIES **************************************************************/
+#include "msg.h"
/* TYPES **********************************************************************/
+
typedef struct _CSR_NT_SESSION
{
ULONG ReferenceCount;
ULONG SessionId;
} CSR_NT_SESSION, *PCSR_NT_SESSION;
+/*** old thingie, remove it later... (put it in winsrv -- console) ***/
+typedef struct _CSRSS_CON_PROCESS_DATA
+{
+ HANDLE ConsoleEvent;
+ struct tagCSRSS_CONSOLE *Console;
+ struct tagCSRSS_CONSOLE *ParentConsole;
+ BOOL bInheritHandles;
+ RTL_CRITICAL_SECTION HandleTableLock;
+ ULONG HandleTableSize;
+ struct _CSRSS_HANDLE *HandleTable;
+ PCONTROLDISPATCHER CtrlDispatcher;
+ LIST_ENTRY ConsoleLink;
+} CSRSS_CON_PROCESS_DATA, *PCSRSS_CON_PROCESS_DATA;
+/*********************************************************************/
typedef struct _CSR_PROCESS
{
CLIENT_ID ClientId;
ULONG Reserved;
ULONG ShutdownLevel;
ULONG ShutdownFlags;
- PVOID ServerData[ANYSIZE_ARRAY];
+// PVOID ServerData[ANYSIZE_ARRAY];
+ CSRSS_CON_PROCESS_DATA; //// FIXME: Remove it after we activate the previous member.
} CSR_PROCESS, *PCSR_PROCESS;
typedef struct _CSR_THREAD
ULONG ImpersonationCount;
} CSR_THREAD, *PCSR_THREAD;
-/* ENUMERATIONS **************************************************************/
-#define CSR_SRV_SERVER 0
+#define CsrGetClientThread() \
+ ((PCSR_THREAD)(NtCurrentTeb()->CsrClientThread))
+
+
+/* ENUMERATIONS ***************************************************************/
typedef enum _CSR_PROCESS_FLAGS
{
- CsrProcessTerminating = 0x1,
- CsrProcessSkipShutdown = 0x2,
- CsrProcessNormalPriority = 0x10,
- CsrProcessIdlePriority = 0x20,
- CsrProcessHighPriority = 0x40,
- CsrProcessRealtimePriority = 0x80,
- CsrProcessCreateNewGroup = 0x100,
- CsrProcessTerminated = 0x200,
+ CsrProcessTerminating = 0x1,
+ CsrProcessSkipShutdown = 0x2,
+ CsrProcessNormalPriority = 0x10,
+ CsrProcessIdlePriority = 0x20,
+ CsrProcessHighPriority = 0x40,
+ CsrProcessRealtimePriority = 0x80,
+ CsrProcessCreateNewGroup = 0x100,
+ CsrProcessTerminated = 0x200,
CsrProcessLastThreadTerminated = 0x400,
- CsrProcessIsConsoleApp = 0x800
+ CsrProcessIsConsoleApp = 0x800
} CSR_PROCESS_FLAGS, *PCSR_PROCESS_FLAGS;
#define CsrProcessPriorityFlags (CsrProcessNormalPriority | \
- CsrProcessIdlePriority | \
- CsrProcessHighPriority | \
+ CsrProcessIdlePriority | \
+ CsrProcessHighPriority | \
CsrProcessRealtimePriority)
typedef enum _CSR_THREAD_FLAGS
{
- CsrThreadAltertable = 0x1,
- CsrThreadInTermination = 0x2,
- CsrThreadTerminated = 0x4,
+ CsrThreadAltertable = 0x1,
+ CsrThreadInTermination = 0x2,
+ CsrThreadTerminated = 0x4,
CsrThreadIsServerThread = 0x10
} CSR_THREAD_FLAGS, *PCSR_THREAD_FLAGS;
typedef enum _CSR_SHUTDOWN_FLAGS
{
CsrShutdownSystem = 4,
- CsrShutdownOther = 8
+ CsrShutdownOther = 8
} CSR_SHUTDOWN_FLAGS, *PCSR_SHUTDOWN_FLAGS;
typedef enum _CSR_DEBUG_FLAGS
CsrDebugProcessChildren = 2
} CSR_PROCESS_DEBUG_FLAGS, *PCSR_PROCESS_DEBUG_FLAGS;
-/* FUNCTION TYPES ************************************************************/
+
+/*
+ * Wait block
+ */
+typedef
+BOOLEAN
+(*CSR_WAIT_FUNCTION)(
+ IN PLIST_ENTRY WaitList,
+ IN PCSR_THREAD WaitThread,
+ IN PCSR_API_MESSAGE WaitApiMessage,
+ IN PVOID WaitContext,
+ IN PVOID WaitArgument1,
+ IN PVOID WaitArgument2,
+ IN ULONG WaitFlags
+);
+
+typedef struct _CSR_WAIT_BLOCK
+{
+ ULONG Size;
+ LIST_ENTRY WaitList;
+ LIST_ENTRY UserWaitList;
+ PVOID WaitContext;
+ PCSR_THREAD WaitThread;
+ CSR_WAIT_FUNCTION WaitFunction;
+ CSR_API_MESSAGE WaitApiMessage;
+} CSR_WAIT_BLOCK, *PCSR_WAIT_BLOCK;
+
+
+/*
+ * Server DLL structure
+ */
+typedef
+NTSTATUS
+(NTAPI *PCSR_API_ROUTINE)(
+ IN OUT PCSR_API_MESSAGE ApiMessage,
+ OUT PULONG Reply
+);
+
+#define CSR_API(n) NTSTATUS NTAPI n ( \
+ IN OUT PCSR_API_MESSAGE ApiMessage, \
+ OUT PULONG Reply)
+
typedef
NTSTATUS
(NTAPI *PCSR_CONNECT_CALLBACK)(
IN BOOLEAN FirstPhase
);
-
-/* FIXME: Put into public NDK Header */
-typedef ULONG CSR_API_NUMBER;
-
-#define CSR_MAKE_OPCODE(s,m) ((s) << 16) | (m)
-#define CSR_API_ID_FROM_OPCODE(n) ((ULONG)((USHORT)(n)))
-#define CSR_SERVER_ID_FROM_OPCODE(n) (ULONG)((n) >> 16)
-
-typedef struct _CSR_CONNECTION_INFO
-{
- ULONG Unknown[2];
- HANDLE ObjectDirectory;
- PVOID SharedSectionBase;
- PVOID SharedSectionHeap;
- PVOID SharedSectionData;
- ULONG DebugFlags;
- ULONG Unknown2[3];
- HANDLE ProcessId;
-} CSR_CONNECTION_INFO, *PCSR_CONNECTION_INFO;
-
-typedef struct _CSR_CLIENT_CONNECT
-{
- ULONG ServerId;
- PVOID ConnectionInfo;
- ULONG ConnectionInfoSize;
-} CSR_CLIENT_CONNECT, *PCSR_CLIENT_CONNECT;
-
-typedef struct _CSR_API_MESSAGE
-{
- PORT_MESSAGE Header;
- union
- {
- CSR_CONNECTION_INFO ConnectionInfo;
- struct
- {
- PVOID CsrCaptureData;
- CSR_API_NUMBER Opcode;
- ULONG Status;
- ULONG Reserved;
- union
- {
- CSR_CLIENT_CONNECT CsrClientConnect;
- };
- };
- };
-} CSR_API_MESSAGE, *PCSR_API_MESSAGE;
-
-typedef struct _CSR_CAPTURE_BUFFER
-{
- ULONG Size;
- struct _CSR_CAPTURE_BUFFER *PreviousCaptureBuffer;
- ULONG PointerCount;
- ULONG_PTR BufferEnd;
-} CSR_CAPTURE_BUFFER, *PCSR_CAPTURE_BUFFER;
-
-/* Private data resumes here */
-typedef
-NTSTATUS
-(NTAPI *PCSR_API_ROUTINE)(
- IN OUT PCSR_API_MESSAGE ApiMessage,
- IN OUT PULONG Reply
-);
-
typedef struct _CSR_SERVER_DLL
{
ULONG Length;
ULONG Unknown2[3];
} CSR_SERVER_DLL, *PCSR_SERVER_DLL;
+
+/* FUNCTION TYPES *************************************************************/
+
typedef
NTSTATUS
-(NTAPI *PCSR_SERVER_DLL_INIT_CALLBACK)(IN PCSR_SERVER_DLL ServerDll);
+(NTAPI *PCSR_SERVER_DLL_INIT_CALLBACK)(IN PCSR_SERVER_DLL LoadedServerDll);
-typedef
-BOOLEAN
-(*CSR_WAIT_FUNCTION)(
- IN PLIST_ENTRY WaitList,
- IN PCSR_THREAD WaitThread,
- IN PCSR_API_MESSAGE WaitApiMessage,
- IN PVOID WaitContext,
- IN PVOID WaitArgument1,
- IN PVOID WaitArgument2,
- IN ULONG WaitFlags
-);
+/*
+NTSTATUS
+NTAPI
+CsrServerDllInitialization(IN PCSR_SERVER_DLL LoadedServerDll);
+*/
-typedef struct _CSR_WAIT_BLOCK
-{
- ULONG Size;
- LIST_ENTRY WaitList;
- LIST_ENTRY UserWaitList;
- PVOID WaitContext;
- PCSR_THREAD WaitThread;
- CSR_WAIT_FUNCTION WaitFunction;
- CSR_API_MESSAGE WaitApiMessage;
-} CSR_WAIT_BLOCK, *PCSR_WAIT_BLOCK;
/* PROTOTYPES ****************************************************************/
NTSTATUS
NTAPI
CsrServerInitialization(
- ULONG ArgumentCount,
- PCHAR Arguments[]
+ IN ULONG ArgumentCount,
+ IN PCHAR Arguments[]
);
+///////////
+BOOLEAN
+NTAPI
+CsrCaptureArguments(
+ IN PCSR_THREAD CsrThread,
+ IN PCSR_API_MESSAGE ApiMessage
+);
+
+VOID
+NTAPI
+CsrReleaseCapturedArguments(IN PCSR_API_MESSAGE ApiMessage);
+//////////
+
+PCSR_THREAD
+NTAPI
+CsrAddStaticServerThread(
+ IN HANDLE hThread,
+ IN PCLIENT_ID ClientId,
+ IN ULONG ThreadFlags
+);
+
+PCSR_THREAD
+NTAPI
+CsrConnectToUser(VOID);
+
+BOOLEAN
+NTAPI
+CsrImpersonateClient(IN PCSR_THREAD CsrThread);
+
+BOOLEAN
+NTAPI
+CsrRevertToSelf(VOID);
+
+VOID
+NTAPI
+CsrSetBackgroundPriority(IN PCSR_PROCESS CsrProcess);
+
+LONG
+NTAPI
+CsrUnhandledExceptionFilter(
+ IN PEXCEPTION_POINTERS ExceptionInfo
+);
+
+
+
#ifdef _MSC_VER
#pragma warning(pop)
#endif
-#endif
+#endif // _CSRSERVER_H
+
+/* EOF */
NTSTATUS Status;
HANDLE ProcessHandle, ThreadHandle;
PCSR_THREAD CsrThread;
- PCSR_PROCESS NewProcessData;
+ PCSR_PROCESS Process, NewProcess;
ULONG Flags, VdmPower = 0, DebugFlags = 0;
/* Get the current client thread */
- CsrThread = NtCurrentTeb()->CsrClientThread;
+ CsrThread = CsrGetClientThread();
ASSERT(CsrThread != NULL);
+ Process = CsrThread->Process;
+
/* Extract the flags out of the process handle */
- Flags = (ULONG_PTR)Request->Data.CreateProcessRequest.ProcessHandle & 3;
- Request->Data.CreateProcessRequest.ProcessHandle = (HANDLE)((ULONG_PTR)Request->Data.CreateProcessRequest.ProcessHandle & ~3);
+ Flags = (ULONG_PTR)ApiMessage->Data.CreateProcessRequest.ProcessHandle & 3;
+ ApiMessage->Data.CreateProcessRequest.ProcessHandle = (HANDLE)((ULONG_PTR)ApiMessage->Data.CreateProcessRequest.ProcessHandle & ~3);
/* Duplicate the process handle */
- Status = NtDuplicateObject(CsrThread->Process->ProcessHandle,
- Request->Data.CreateProcessRequest.ProcessHandle,
+ Status = NtDuplicateObject(Process->ProcessHandle,
+ ApiMessage->Data.CreateProcessRequest.ProcessHandle,
NtCurrentProcess(),
&ProcessHandle,
0,
}
/* Duplicate the thread handle */
- Status = NtDuplicateObject(CsrThread->Process->ProcessHandle,
- Request->Data.CreateProcessRequest.ThreadHandle,
+ Status = NtDuplicateObject(Process->ProcessHandle,
+ ApiMessage->Data.CreateProcessRequest.ThreadHandle,
NtCurrentProcess(),
&ThreadHandle,
0,
}
/* Convert some flags. FIXME: More need conversion */
- if (Request->Data.CreateProcessRequest.CreationFlags & CREATE_NEW_PROCESS_GROUP)
+ if (ApiMessage->Data.CreateProcessRequest.CreationFlags & CREATE_NEW_PROCESS_GROUP)
{
DebugFlags |= CsrProcessCreateNewGroup;
}
/* Call CSRSRV to create the CSR_PROCESS structure and the first CSR_THREAD */
Status = CsrCreateProcess(ProcessHandle,
ThreadHandle,
- &Request->Data.CreateProcessRequest.ClientId,
- CsrThread->Process->NtSession,
+ &ApiMessage->Data.CreateProcessRequest.ClientId,
+ Process->NtSession,
DebugFlags,
NULL);
if (Status == STATUS_THREAD_IS_TERMINATING)
/* FIXME: VDM vodoo */
/* ReactOS Compatibility */
- Status = CsrLockProcessByClientId(Request->Data.CreateProcessRequest.ClientId.UniqueProcess, &NewProcessData);
+ Status = CsrLockProcessByClientId(ApiMessage->Data.CreateProcessRequest.ClientId.UniqueProcess, &NewProcess);
ASSERT(Status == STATUS_SUCCESS);
- if (!(Request->Data.CreateProcessRequest.CreationFlags & (CREATE_NEW_CONSOLE | DETACHED_PROCESS)))
+ if (!(ApiMessage->Data.CreateProcessRequest.CreationFlags & (CREATE_NEW_CONSOLE | DETACHED_PROCESS)))
{
- NewProcessData->ParentConsole = ProcessData->Console;
- NewProcessData->bInheritHandles = Request->Data.CreateProcessRequest.bInheritHandles;
+ NewProcess->ParentConsole = Process->Console;
+ NewProcess->bInheritHandles = ApiMessage->Data.CreateProcessRequest.bInheritHandles;
}
- RtlInitializeCriticalSection(&NewProcessData->HandleTableLock);
- CallProcessCreated(ProcessData, NewProcessData);
- CsrUnlockProcess(NewProcessData);
+ RtlInitializeCriticalSection(&NewProcess->HandleTableLock);
+ CallProcessCreated(Process, NewProcess);
+ CsrUnlockProcess(NewProcess);
/* Return the result of this operation */
return Status;
PCSR_PROCESS CsrProcess;
/* Get the current CSR thread */
- CurrentThread = NtCurrentTeb()->CsrClientThread;
+ CurrentThread = CsrGetClientThread();
if (!CurrentThread)
{
DPRINT1("Server Thread TID: [%lx.%lx]\n",
- Request->Data.CreateThreadRequest.ClientId.UniqueProcess,
- Request->Data.CreateThreadRequest.ClientId.UniqueThread);
+ ApiMessage->Data.CreateThreadRequest.ClientId.UniqueProcess,
+ ApiMessage->Data.CreateThreadRequest.ClientId.UniqueThread);
return STATUS_SUCCESS; // server-to-server
}
/* Get the CSR Process for this request */
CsrProcess = CurrentThread->Process;
if (CsrProcess->ClientId.UniqueProcess !=
- Request->Data.CreateThreadRequest.ClientId.UniqueProcess)
+ ApiMessage->Data.CreateThreadRequest.ClientId.UniqueProcess)
{
/* This is a remote thread request -- is it within the server itself? */
- if (Request->Data.CreateThreadRequest.ClientId.UniqueProcess == NtCurrentTeb()->ClientId.UniqueProcess)
+ if (ApiMessage->Data.CreateThreadRequest.ClientId.UniqueProcess == NtCurrentTeb()->ClientId.UniqueProcess)
{
/* Accept this without any further work */
return STATUS_SUCCESS;
}
/* Get the real CSR Process for the remote thread's process */
- Status = CsrLockProcessByClientId(Request->Data.CreateThreadRequest.ClientId.UniqueProcess,
+ Status = CsrLockProcessByClientId(ApiMessage->Data.CreateThreadRequest.ClientId.UniqueProcess,
&CsrProcess);
if (!NT_SUCCESS(Status)) return Status;
}
/* Duplicate the thread handle so we can own it */
Status = NtDuplicateObject(CurrentThread->Process->ProcessHandle,
- Request->Data.CreateThreadRequest.ThreadHandle,
+ ApiMessage->Data.CreateThreadRequest.ThreadHandle,
NtCurrentProcess(),
&ThreadHandle,
0,
/* Call CSRSRV to tell it about the new thread */
Status = CsrCreateThread(CsrProcess,
ThreadHandle,
- &Request->Data.CreateThreadRequest.ClientId);
+ &ApiMessage->Data.CreateThreadRequest.ClientId);
}
/* Unlock the process and return */
CSR_API(CsrTerminateProcess)
{
- PCSR_THREAD CsrThread = NtCurrentTeb()->CsrClientThread;
+ PCSR_THREAD CsrThread = CsrGetClientThread();
ASSERT(CsrThread != NULL);
/* Set magic flag so we don't reply this message back */
- Request->Type = 0xBABE;
+ ApiMessage->ApiNumber = 0xBABE;
/* Remove the CSR_THREADs and CSR_PROCESS */
return CsrDestroyProcess(&CsrThread->ClientId,
- (NTSTATUS)Request->Data.TerminateProcessRequest.uExitCode);
+ (NTSTATUS)ApiMessage->Data.TerminateProcessRequest.uExitCode);
}
CSR_API(CsrConnectProcess)
{
-
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
CSR_API(CsrGetShutdownParameters)
{
+ PCSR_THREAD CsrThread = CsrGetClientThread();
+ ASSERT(CsrThread);
- Request->Data.GetShutdownParametersRequest.Level = ProcessData->ShutdownLevel;
- Request->Data.GetShutdownParametersRequest.Flags = ProcessData->ShutdownFlags;
+ ApiMessage->Data.GetShutdownParametersRequest.Level = CsrThread->Process->ShutdownLevel;
+ ApiMessage->Data.GetShutdownParametersRequest.Flags = CsrThread->Process->ShutdownFlags;
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
CSR_API(CsrSetShutdownParameters)
{
+ PCSR_THREAD CsrThread = CsrGetClientThread();
+ ASSERT(CsrThread);
- ProcessData->ShutdownLevel = Request->Data.SetShutdownParametersRequest.Level;
- ProcessData->ShutdownFlags = Request->Data.SetShutdownParametersRequest.Flags;
+ CsrThread->Process->ShutdownLevel = ApiMessage->Data.SetShutdownParametersRequest.Level;
+ CsrThread->Process->ShutdownFlags = ApiMessage->Data.SetShutdownParametersRequest.Flags;
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
/* EOF */
}
else
{
- ServicesProcessId = (ULONG_PTR)Request->Data.RegisterServicesProcessRequest.ProcessId;
+ ServicesProcessId = (ULONG_PTR)ApiMessage->Data.RegisterServicesProcessRequest.ProcessId;
ServicesProcessIdValid = TRUE;
return STATUS_SUCCESS;
}
return STATUS_SUCCESS;
}
+/*
VOID
FASTCALL
CsrApiCallHandler(PCSR_PROCESS ProcessData,
PCSR_API_MESSAGE Request)
+*/
+VOID
+FASTCALL
+CsrApiCallHandler(
+ IN OUT PCSR_API_MESSAGE ApiMessage,
+ OUT PULONG Reply
+)
{
unsigned DefIndex;
- ULONG Type;
+ ULONG ApiId;
- DPRINT("CSR: Calling handler for type: %x.\n", Request->Type);
- Type = Request->Type & 0xFFFF; /* FIXME: USE MACRO */
- DPRINT("CSR: API Number: %x ServerID: %x\n",Type, Request->Type >> 16);
+ DPRINT("CSR: Calling handler for ApiNumber: %x.\n", ApiMessage->ApiNumber);
+ ApiId = CSR_API_NUMBER_TO_API_ID(ApiMessage->ApiNumber);
+ DPRINT("CSR: ApiID: %x ServerID: %x\n", ApiId, CSR_API_NUMBER_TO_SERVER_ID(ApiMessage->ApiNumber));
/* FIXME: Extract DefIndex instead of looping */
for (DefIndex = 0; DefIndex < ApiDefinitionsCount; DefIndex++)
{
- if (ApiDefinitions[DefIndex].Type == Type)
+ if (ApiDefinitions[DefIndex].ApiID == ApiId)
{
- if (Request->Header.u1.s1.DataLength < ApiDefinitions[DefIndex].MinRequestSize)
+ if (ApiMessage->Header.u1.s1.DataLength < ApiDefinitions[DefIndex].MinRequestSize)
{
- DPRINT1("Request type %d min request size %d actual %d\n",
- Type, ApiDefinitions[DefIndex].MinRequestSize,
- Request->Header.u1.s1.DataLength);
- Request->Status = STATUS_INVALID_PARAMETER;
+ DPRINT1("Request ApiID %d min request size %d actual %d\n",
+ ApiId, ApiDefinitions[DefIndex].MinRequestSize,
+ ApiMessage->Header.u1.s1.DataLength);
+ ApiMessage->Status = STATUS_INVALID_PARAMETER;
}
else
{
- Request->Status = (ApiDefinitions[DefIndex].Handler)(ProcessData, Request);
+ ApiMessage->Status = (ApiDefinitions[DefIndex].Handler)(ApiMessage, Reply);
}
return;
}
}
- DPRINT1("CSR: Unknown request type 0x%x\n", Request->Type);
- Request->Status = STATUS_INVALID_SYSTEM_SERVICE;
+ DPRINT1("CSR: Unknown request ApiNumber 0x%x\n", ApiMessage->ApiNumber);
+ ApiMessage->Status = STATUS_INVALID_SYSTEM_SERVICE;
}
VOID
* Pointer to the CSR API Message to receive from the server.
*
* @return STATUS_SUCCESS in case of success, STATUS_ILLEGAL_FUNCTION
- * if the opcode is invalid, or STATUS_ACCESS_VIOLATION if there
+ * if the ApiNumber is invalid, or STATUS_ACCESS_VIOLATION if there
* was a problem executing the API.
*
* @remarks None.
NTSTATUS Status;
/* Get the Server ID */
- ServerId = CSR_SERVER_ID_FROM_OPCODE(ReceiveMsg->Opcode);
+ ServerId = CSR_SERVER_ID_FROM_OPCODE(ReceiveMsg->ApiNumber);
/* Make sure that the ID is within limits, and the Server DLL loaded */
if ((ServerId >= CSR_SERVER_DLL_MAX) ||
else
{
/* Get the API ID */
- ApiId = CSR_API_ID_FROM_OPCODE(ReceiveMsg->Opcode);
+ ApiId = CSR_API_NUMBER_TO_API_ID(ReceiveMsg->ApiNumber);
/* Normalize it with our Base ID */
ApiId -= ServerDll->ApiBase;
#else // Hacky reactos code
PCSR_PROCESS ProcessData;
+ ULONG ReplyCode;
/* Get the Process Data */
CsrLockProcessByClientId(&ReceiveMsg->Header.ClientId.UniqueProcess, &ProcessData);
_SEH2_TRY
{
/* Call the API and get the result */
- CsrApiCallHandler(ProcessData, ReplyMsg);
+ CsrApiCallHandler(ReplyMsg, /*ProcessData*/ &ReplyCode);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
{
/* This is an API Message coming from a non-CSR Thread */
DPRINT1("No thread found for request %lx and clientID %lx.%lx\n",
- Request->Type & 0xFFFF,
+ Request->ApiNumber & 0xFFFF,
Request->Header.ClientId.UniqueProcess,
Request->Header.ClientId.UniqueThread);
Reply = Request;
ReplyPort = CsrThread->Process->ClientPort;
DPRINT("CSR: Got CSR API: %x [Message Origin: %x]\n",
- Request->Type,
+ Request->ApiNumber,
Request->Header.ClientId.UniqueThread);
/* Validation complete, start SEH */
_SEH2_TRY
{
+ ULONG ReplyCode;
+
/* Make sure we have enough threads */
CsrpCheckRequestThreads();
NtCurrentTeb()->CsrClientThread = CsrThread;
/* Call the Handler */
- CsrApiCallHandler(CsrThread->Process, Request);
+ CsrApiCallHandler(Request, &ReplyCode);
/* Increase the static thread count */
_InterlockedIncrement(&CsrpStaticThreadCount);
NtCurrentTeb()->CsrClientThread = ServerThread;
/* Check if this is a dead client now */
- if (Request->Type == 0xBABE)
+ if (Request->ApiNumber == 0xBABE)
{
/* Reply to the death message */
NtReplyPort(ReplyPort, &Reply->Header);
CsrImpersonateClient(IN PCSR_THREAD CsrThread)
{
NTSTATUS Status;
- PCSR_THREAD CurrentThread = NtCurrentTeb()->CsrClientThread;
+ PCSR_THREAD CurrentThread = CsrGetClientThread();
/* Use the current thread if none given */
if (!CsrThread) CsrThread = CurrentThread;
CsrRevertToSelf(VOID)
{
NTSTATUS Status;
- PCSR_THREAD CurrentThread = NtCurrentTeb()->CsrClientThread;
+ PCSR_THREAD CurrentThread = CsrGetClientThread();
HANDLE ImpersonationToken = NULL;
/* Check if we have a Current Thread */
IN ULONG Flags,
IN PCLIENT_ID DebugCid)
{
- PCSR_THREAD CurrentThread = NtCurrentTeb()->CsrClientThread;
+ PCSR_THREAD CurrentThread = CsrGetClientThread();
CLIENT_ID CurrentCid;
PCSR_PROCESS CurrentProcess;
// PVOID ProcessData;
NTSTATUS Status;
PCSR_CLIENT_CONNECT ClientConnect;
PCSR_SERVER_DLL ServerDll;
- PCSR_PROCESS CurrentProcess = ((PCSR_THREAD)NtCurrentTeb()->CsrClientThread)->Process;
+ PCSR_PROCESS CurrentProcess = CsrGetClientThread()->Process;
/* Load the Message, set default reply */
ClientConnect = (PCSR_CLIENT_CONNECT)&ApiMessage->CsrClientConnect;
CsrSrvIdentifyAlertableThread(IN OUT PCSR_API_MESSAGE ApiMessage,
IN OUT PULONG Reply)
{
- PCSR_THREAD CsrThread = NtCurrentTeb()->CsrClientThread;
+ PCSR_THREAD CsrThread = CsrGetClientThread();
/* Set the alertable flag */
CsrThread->Flags |= CsrThreadAltertable;
{
PCSR_THREAD CsrThread;
PCSR_PROCESS CurrentProcess;
- PCSR_THREAD CurrentThread = NtCurrentTeb()->CsrClientThread;
+ PCSR_THREAD CurrentThread = CsrGetClientThread();
CLIENT_ID CurrentCid;
KERNEL_USER_TIMES KernelTimes;
#include <ndk/psfuncs.h>
#include <ndk/rtlfuncs.h>
-#include <csrss/csrss.h>
-
-#define CSR_SRV_SERVER 0
-#define CSR_SERVER_DLL_MAX 4
-#define LOCK RtlEnterCriticalSection(&ProcessDataLock)
-#define UNLOCK RtlLeaveCriticalSection(&ProcessDataLock)
-#define CsrAcquireProcessLock() LOCK
-#define CsrReleaseProcessLock() UNLOCK
+#include <csrss/server.h>
+
+
+#define CsrAcquireProcessLock() \
+ RtlEnterCriticalSection(&ProcessDataLock); // CsrProcessLock
+
+#define CsrReleaseProcessLock() \
+ RtlLeaveCriticalSection(&ProcessDataLock);
+
#define ProcessStructureListLocked() \
(ProcessDataLock.OwningThread == NtCurrentTeb()->ClientId.UniqueThread)
#define CsrReleaseNtSessionLock() \
RtlLeaveCriticalSection(&CsrNtSessionLock);
-typedef enum _CSR_THREAD_FLAGS
-{
- CsrThreadAltertable = 0x1,
- CsrThreadInTermination = 0x2,
- CsrThreadTerminated = 0x4,
- CsrThreadIsServerThread = 0x10
-} CSR_THREAD_FLAGS, *PCSR_THREAD_FLAGS;
-
-typedef enum _SHUTDOWN_RESULT
-{
- CsrShutdownCsrProcess = 1,
- CsrShutdownNonCsrProcess,
- CsrShutdownCancelled
-} SHUTDOWN_RESULT, *PSHUTDOWN_RESULT;
-
-typedef enum _CSR_SHUTDOWN_FLAGS
-{
- CsrShutdownSystem = 4,
- CsrShutdownOther = 8
-} CSR_SHUTDOWN_FLAGS, *PCSR_SHUTDOWN_FLAGS;
-
-typedef enum _CSR_DEBUG_FLAGS
-{
- CsrDebugOnlyThisProcess = 1,
- CsrDebugProcessChildren = 2
-} CSR_PROCESS_DEBUG_FLAGS, *PCSR_PROCESS_DEBUG_FLAGS;
-
-typedef enum _CSR_PROCESS_FLAGS
-{
- CsrProcessTerminating = 0x1,
- CsrProcessSkipShutdown = 0x2,
- CsrProcessNormalPriority = 0x10,
- CsrProcessIdlePriority = 0x20,
- CsrProcessHighPriority = 0x40,
- CsrProcessRealtimePriority = 0x80,
- CsrProcessCreateNewGroup = 0x100,
- CsrProcessTerminated = 0x200,
- CsrProcessLastThreadTerminated = 0x400,
- CsrProcessIsConsoleApp = 0x800
-} CSR_PROCESS_FLAGS, *PCSR_PROCESS_FLAGS;
-
-#define CsrProcessPriorityFlags (CsrProcessNormalPriority | \
- CsrProcessIdlePriority | \
- CsrProcessHighPriority | \
- CsrProcessRealtimePriority)
-
-typedef struct _CSRSS_CON_PROCESS_DATA
-{
- HANDLE ConsoleEvent;
- struct tagCSRSS_CONSOLE *Console;
- struct tagCSRSS_CONSOLE *ParentConsole;
- BOOL bInheritHandles;
- RTL_CRITICAL_SECTION HandleTableLock;
- ULONG HandleTableSize;
- struct _CSRSS_HANDLE *HandleTable;
- PCONTROLDISPATCHER CtrlDispatcher;
- LIST_ENTRY ConsoleLink;
-} CSRSS_CON_PROCESS_DATA, *PCSRSS_CON_PROCESS_DATA;
-
-typedef struct _CSR_NT_SESSION
-{
- ULONG ReferenceCount;
- LIST_ENTRY SessionLink;
- ULONG SessionId;
-} CSR_NT_SESSION, *PCSR_NT_SESSION;
-typedef struct _CSR_PROCESS
-{
- CLIENT_ID ClientId;
- LIST_ENTRY ListLink;
- LIST_ENTRY ThreadList;
- struct _CSR_PROCESS *Parent;
- PCSR_NT_SESSION NtSession;
- ULONG ExpectedVersion;
- HANDLE ClientPort;
- ULONG_PTR ClientViewBase;
- ULONG_PTR ClientViewBounds;
- HANDLE ProcessHandle;
- ULONG SequenceNumber;
- ULONG Flags;
- ULONG DebugFlags;
- CLIENT_ID DebugCid;
- ULONG ReferenceCount;
- ULONG ProcessGroupId;
- ULONG ProcessGroupSequence;
- ULONG fVDM;
- ULONG ThreadCount;
- ULONG PriorityClass;
- ULONG Reserved;
- ULONG ShutdownLevel;
- ULONG ShutdownFlags;
-// PVOID ServerData[ANYSIZE_ARRAY];
- CSRSS_CON_PROCESS_DATA;
-} CSR_PROCESS, *PCSR_PROCESS;
-
-typedef struct _CSR_THREAD
-{
- LARGE_INTEGER CreateTime;
- LIST_ENTRY Link;
- LIST_ENTRY HashLinks;
- CLIENT_ID ClientId;
- PCSR_PROCESS Process;
- struct _CSR_WAIT_BLOCK *WaitBlock;
- HANDLE ThreadHandle;
- ULONG Flags;
- ULONG ReferenceCount;
- ULONG ImpersonationCount;
-} CSR_THREAD, *PCSR_THREAD;
-
-typedef
-BOOLEAN
-(*CSR_WAIT_FUNCTION)(
- IN PLIST_ENTRY WaitList,
- IN PCSR_THREAD WaitThread,
- IN PCSR_API_MESSAGE WaitApiMessage,
- IN PVOID WaitContext,
- IN PVOID WaitArgument1,
- IN PVOID WaitArgument2,
- IN ULONG WaitFlags
-);
-typedef struct _CSR_WAIT_BLOCK
+typedef struct _CSRSS_API_DEFINITION
{
- ULONG Size;
- LIST_ENTRY WaitList;
- LIST_ENTRY UserWaitList;
- PVOID WaitContext;
- PCSR_THREAD WaitThread;
- CSR_WAIT_FUNCTION WaitFunction;
- CSR_API_MESSAGE WaitApiMessage;
-} CSR_WAIT_BLOCK, *PCSR_WAIT_BLOCK;
-
-typedef
-NTSTATUS
-(NTAPI *PCSR_CONNECT_CALLBACK)(
- IN PCSR_PROCESS CsrProcess,
- IN OUT PVOID ConnectionInfo,
- IN OUT PULONG ConnectionInfoLength
-);
-
-typedef
-VOID
-(NTAPI *PCSR_DISCONNECT_CALLBACK)(IN PCSR_PROCESS CsrProcess);
-
-typedef
-NTSTATUS
-(NTAPI *PCSR_NEWPROCESS_CALLBACK)(
- IN PCSR_PROCESS Parent,
- IN PCSR_PROCESS CsrProcess
-);
+ ULONG ApiID;
+ ULONG MinRequestSize;
+ PCSR_API_ROUTINE Handler;
+} CSRSS_API_DEFINITION, *PCSRSS_API_DEFINITION;
-typedef
-VOID
-(NTAPI *PCSR_HARDERROR_CALLBACK)(
- IN PCSR_THREAD CsrThread,
- IN PHARDERROR_MSG HardErrorMessage
-);
+#define CSRSS_DEFINE_API(Func, Handler) \
+ { Func, sizeof(CSRSS_##Func), Handler }
-typedef
-ULONG
-(NTAPI *PCSR_SHUTDOWNPROCESS_CALLBACK)(
- IN PCSR_PROCESS CsrProcess,
- IN ULONG Flags,
- IN BOOLEAN FirstPhase
-);
-typedef
-NTSTATUS
-(NTAPI *PCSR_API_ROUTINE)(
- IN OUT PCSR_API_MESSAGE ApiMessage,
- IN OUT PULONG Reply
-);
-typedef struct _CSR_SERVER_DLL
+typedef struct _CSRSS_LISTEN_DATA
{
- ULONG Length;
- HANDLE Event;
- ANSI_STRING Name;
- HANDLE ServerHandle;
- ULONG ServerId;
- ULONG Unknown;
- ULONG ApiBase;
- ULONG HighestApiSupported;
- PCSR_API_ROUTINE *DispatchTable;
- PBOOLEAN ValidTable;
- PCHAR *NameTable;
- ULONG SizeOfProcessData;
- PCSR_CONNECT_CALLBACK ConnectCallback;
- PCSR_DISCONNECT_CALLBACK DisconnectCallback;
- PCSR_HARDERROR_CALLBACK HardErrorCallback;
- PVOID SharedSection;
- PCSR_NEWPROCESS_CALLBACK NewProcessCallback;
- PCSR_SHUTDOWNPROCESS_CALLBACK ShutdownProcessCallback;
- ULONG Unknown2[3];
-} CSR_SERVER_DLL, *PCSR_SERVER_DLL;
-
-typedef
-NTSTATUS
-(NTAPI *PCSR_SERVER_DLL_INIT_CALLBACK)(IN PCSR_SERVER_DLL ServerDll);
+ HANDLE ApiPortHandle;
+ ULONG ApiDefinitionsCount;
+ PCSRSS_API_DEFINITION *ApiDefinitions;
+} CSRSS_LISTEN_DATA, *PCSRSS_LISTEN_DATA;
-typedef NTSTATUS (WINAPI *CSRSS_API_PROC)(PCSR_PROCESS ProcessData,
- PCSR_API_MESSAGE Request);
-typedef struct _CSRSS_API_DEFINITION
-{
- ULONG Type;
- ULONG MinRequestSize;
- CSRSS_API_PROC Handler;
-} CSRSS_API_DEFINITION, *PCSRSS_API_DEFINITION;
-#define CSRSS_DEFINE_API(Func, Handler) \
- { Func, sizeof(CSRSS_##Func), Handler }
+/******************************************************************************
+ ******************************************************************************
+ ******************************************************************************/
-typedef struct _CSRSS_LISTEN_DATA
-{
- HANDLE ApiPortHandle;
- ULONG ApiDefinitionsCount;
- PCSRSS_API_DEFINITION *ApiDefinitions;
-} CSRSS_LISTEN_DATA, *PCSRSS_LISTEN_DATA;
-#define CSR_API(n) NTSTATUS WINAPI n ( \
- PCSR_PROCESS ProcessData, \
- PCSR_API_MESSAGE Request)
/* init.c */
extern HANDLE hBootstrapOk;
/* api/wapi.c */
NTSTATUS FASTCALL CsrApiRegisterDefinitions(PCSRSS_API_DEFINITION NewDefinitions);
-VOID FASTCALL CsrApiCallHandler(PCSR_PROCESS ProcessData,
- PCSR_API_MESSAGE Request);
+VOID FASTCALL CsrApiCallHandler(IN OUT PCSR_API_MESSAGE ApiMessage, OUT PULONG Reply);
VOID WINAPI CsrSbApiRequestThread (PVOID PortHandle);
VOID NTAPI ClientConnectionThread(HANDLE ServerPort);
-VOID
-NTAPI
-CsrReleaseCapturedArguments(IN PCSR_API_MESSAGE ApiMessage);
-
extern HANDLE CsrApiPort;
extern HANDLE CsrSmApiPort;
extern HANDLE CsrSbApiPort;
/* api/process.c */
typedef NTSTATUS (WINAPI *CSRSS_ENUM_PROCESS_PROC)(PCSR_PROCESS ProcessData,
- PVOID Context);
+ PVOID Context);
NTSTATUS WINAPI CsrInitializeProcessStructure(VOID);
NTSTATUS WINAPI CsrEnumProcesses(CSRSS_ENUM_PROCESS_PROC EnumProc, PVOID Context);
/* SEH support with PSEH */
#include <pseh/pseh2.h>
-/* CSRSS header */
-#include <csrss/csrss.h>
+/* CSRSS Header */
+#include <csrss/client.h>
+#include <csrss/csrss.h> // FIXME: data header.
/* Public Win32K headers */
#include <include/callback.h>
NULL,
NULL,
&ConnectInfoLength);
- if (! NT_SUCCESS(Status))
+ if (!NT_SUCCESS(Status))
{
return Status;
}
/*
* Create a handle for CSRSS and notify CSRSS for Creating Desktop Background Windows and Threads.
*/
- Request.Type = MAKE_CSR_API(CREATE_DESKTOP, CSR_GUI);
+ Request.ApiNumber = CSR_CREATE_API_NUMBER(CSR_GUI, CREATE_DESKTOP);
Status = CsrInsertObject(Desktop,
GENERIC_ALL,
(HANDLE*)&Request.Data.CreateDesktopRequest.DesktopHandle);
ObDereferenceObject(Process);
- Request.Type = MAKE_CSR_API(REGISTER_LOGON_PROCESS, CSR_GUI);
+ Request.ApiNumber = CSR_CREATE_API_NUMBER(CSR_GUI, REGISTER_LOGON_PROCESS);
Request.Data.RegisterLogonProcessRequest.ProcessId = ProcessId;
Request.Data.RegisterLogonProcessRequest.Register = Register;
#include <ndk/rtlfuncs.h>
#include <ndk/umfuncs.h>
-/* CSRSS Headers */
-#include <csrss/csrss.h>
+/* CSRSS Header */
+#include <csrss/client.h>
+#include <csrss/csrss.h> // FIXME: data header.
/* Public Win32K Headers */
#include <ntusrtyp.h>
#define HOOKID_TO_FLAG(HookId) (1 << ((HookId) + 1))
#define ISITHOOKED(HookId) (GetWin32ClientInfo()->fsHooks & HOOKID_TO_FLAG(HookId) ||\
(GetWin32ClientInfo()->pDeskInfo && GetWin32ClientInfo()->pDeskInfo->fsHooks & HOOKID_TO_FLAG(HookId)))
-
\ No newline at end of file
*/
BOOL WINAPI
ExitWindowsEx(UINT uFlags,
- DWORD dwReserved)
+ DWORD dwReserved)
{
- CSR_API_MESSAGE Request;
- ULONG CsrRequest;
- NTSTATUS Status;
+ CSR_API_MESSAGE Request;
+ NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(EXIT_REACTOS, CSR_GUI);
- Request.Data.ExitReactosRequest.Flags = uFlags;
- Request.Data.ExitReactosRequest.Reserved = dwReserved;
+ Request.Data.ExitReactosRequest.Flags = uFlags;
+ Request.Data.ExitReactosRequest.Reserved = dwReserved;
- Status = CsrClientCallServer(&Request,
- NULL,
- CsrRequest,
- sizeof(CSR_API_MESSAGE));
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_GUI, EXIT_REACTOS),
+ sizeof(CSR_API_MESSAGE));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
- SetLastError(RtlNtStatusToDosError(Status));
- return(FALSE);
+ SetLastError(RtlNtStatusToDosError(Status));
+ return FALSE;
}
- return(TRUE);
+ return TRUE;
}
BOOL WINAPI
RegisterServicesProcess(DWORD ServicesProcessId)
{
- CSR_API_MESSAGE Request;
- ULONG CsrRequest;
- NTSTATUS Status;
+ CSR_API_MESSAGE Request;
+ NTSTATUS Status;
- CsrRequest = MAKE_CSR_API(REGISTER_SERVICES_PROCESS, CSR_GUI);
- Request.Data.RegisterServicesProcessRequest.ProcessId = UlongToHandle(ServicesProcessId);
+ Request.Data.RegisterServicesProcessRequest.ProcessId = UlongToHandle(ServicesProcessId);
- Status = CsrClientCallServer(&Request,
- NULL,
- CsrRequest,
- sizeof(CSR_API_MESSAGE));
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_GUI, REGISTER_SERVICES_PROCESS),
+ sizeof(CSR_API_MESSAGE));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
- SetLastError(RtlNtStatusToDosError(Status));
- return(FALSE);
+ SetLastError(RtlNtStatusToDosError(Status));
+ return FALSE;
}
- return(TRUE);
+ return TRUE;
}
/* EOF */
WINAPI
SetLogonNotifyWindow (HWND Wnd, HWINSTA WinSta)
{
- /* Maybe we should call NtUserSetLogonNotifyWindow and let that one inform CSRSS??? */
- CSR_API_MESSAGE Request;
- ULONG CsrRequest;
- NTSTATUS Status;
-
- CsrRequest = MAKE_CSR_API(SET_LOGON_NOTIFY_WINDOW, CSR_GUI);
- Request.Data.SetLogonNotifyWindowRequest.LogonNotifyWindow = Wnd;
-
- Status = CsrClientCallServer(&Request,
- NULL,
- CsrRequest,
- sizeof(CSR_API_MESSAGE));
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
+ /* Maybe we should call NtUserSetLogonNotifyWindow and let that one inform CSRSS??? */
+ CSR_API_MESSAGE Request;
+ NTSTATUS Status;
+
+ Request.Data.SetLogonNotifyWindowRequest.LogonNotifyWindow = Wnd;
+
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CSR_CREATE_API_NUMBER(CSR_GUI, SET_LOGON_NOTIFY_WINDOW),
+ sizeof(CSR_API_MESSAGE));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
- SetLastError(RtlNtStatusToDosError(Status));
- return(FALSE);
+ SetLastError(RtlNtStatusToDosError(Status));
+ return FALSE;
}
- return NtUserSetLogonNotifyWindow(Wnd);
+ return NtUserSetLogonNotifyWindow(Wnd);
}
/*
//ULONG TotalLength;
//WCHAR * Ptr;
- //TotalLength = Request->Data.AddConsoleAlias.SourceLength + Request->Data.AddConsoleAlias.ExeLength + Request->Data.AddConsoleAlias.TargetLength;
- //Ptr = (WCHAR*)((ULONG_PTR)Request + sizeof(CSR_API_MESSAGE));
+ //TotalLength = ApiMessage->Data.AddConsoleAlias.SourceLength + ApiMessage->Data.AddConsoleAlias.ExeLength + ApiMessage->Data.AddConsoleAlias.TargetLength;
+ //Ptr = (WCHAR*)((ULONG_PTR)ApiMessage + sizeof(CSR_API_MESSAGE));
- lpSource = (WCHAR*)((ULONG_PTR)Request + sizeof(CSR_API_MESSAGE));
- lpExeName = (WCHAR*)((ULONG_PTR)Request + sizeof(CSR_API_MESSAGE) + Request->Data.AddConsoleAlias.SourceLength * sizeof(WCHAR));
- lpTarget = (Request->Data.AddConsoleAlias.TargetLength != 0 ? lpExeName + Request->Data.AddConsoleAlias.ExeLength : NULL);
+ lpSource = (WCHAR*)((ULONG_PTR)ApiMessage + sizeof(CSR_API_MESSAGE));
+ lpExeName = (WCHAR*)((ULONG_PTR)ApiMessage + sizeof(CSR_API_MESSAGE) + ApiMessage->Data.AddConsoleAlias.SourceLength * sizeof(WCHAR));
+ lpTarget = (ApiMessage->Data.AddConsoleAlias.TargetLength != 0 ? lpExeName + ApiMessage->Data.AddConsoleAlias.ExeLength : NULL);
- DPRINT("CsrAddConsoleAlias entered Request %p lpSource %p lpExeName %p lpTarget %p\n", Request, lpSource, lpExeName, lpTarget);
+ DPRINT("CsrAddConsoleAlias entered ApiMessage %p lpSource %p lpExeName %p lpTarget %p\n", ApiMessage, lpSource, lpExeName, lpTarget);
if (lpExeName == NULL || lpSource == NULL)
{
return STATUS_INVALID_PARAMETER;
}
- Request->Status = ConioConsoleFromProcessData(ProcessData, &Console);
- if (!NT_SUCCESS(Request->Status))
+ ApiMessage->Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
+ if (!NT_SUCCESS(ApiMessage->Status))
{
- return Request->Status;
+ return ApiMessage->Status;
}
Header = IntFindAliasHeader(Console->Aliases, lpExeName);
if (Entry)
{
IntDeleteAliasEntry(Header, Entry);
- Request->Status = STATUS_SUCCESS;
+ ApiMessage->Status = STATUS_SUCCESS;
}
else
{
- Request->Status = STATUS_INVALID_PARAMETER;
+ ApiMessage->Status = STATUS_INVALID_PARAMETER;
}
ConioUnlockConsole(Console);
- return Request->Status;
+ return ApiMessage->Status;
}
Entry = IntCreateAliasEntry(lpSource, lpTarget);
WCHAR * lpSource;
WCHAR * lpTarget;
- lpSource = (LPWSTR)((ULONG_PTR)Request + sizeof(CSR_API_MESSAGE));
- lpExeName = lpSource + Request->Data.GetConsoleAlias.SourceLength;
- lpTarget = Request->Data.GetConsoleAlias.TargetBuffer;
+ lpSource = (LPWSTR)((ULONG_PTR)ApiMessage + sizeof(CSR_API_MESSAGE));
+ lpExeName = lpSource + ApiMessage->Data.GetConsoleAlias.SourceLength;
+ lpTarget = ApiMessage->Data.GetConsoleAlias.TargetBuffer;
DPRINT("CsrGetConsoleAlias entered lpExeName %p lpSource %p TargetBuffer %p TargetBufferLength %u\n",
- lpExeName, lpSource, lpTarget, Request->Data.GetConsoleAlias.TargetBufferLength);
+ lpExeName, lpSource, lpTarget, ApiMessage->Data.GetConsoleAlias.TargetBufferLength);
- if (Request->Data.GetConsoleAlias.ExeLength == 0 || lpTarget == NULL ||
- Request->Data.GetConsoleAlias.TargetBufferLength == 0 || Request->Data.GetConsoleAlias.SourceLength == 0)
+ if (ApiMessage->Data.GetConsoleAlias.ExeLength == 0 || lpTarget == NULL ||
+ ApiMessage->Data.GetConsoleAlias.TargetBufferLength == 0 || ApiMessage->Data.GetConsoleAlias.SourceLength == 0)
{
return STATUS_INVALID_PARAMETER;
}
- Request->Status = ConioConsoleFromProcessData(ProcessData, &Console);
- if (!NT_SUCCESS(Request->Status))
+ ApiMessage->Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
+ if (!NT_SUCCESS(ApiMessage->Status))
{
- return Request->Status;
+ return ApiMessage->Status;
}
Header = IntFindAliasHeader(Console->Aliases, lpExeName);
}
Length = (wcslen(Entry->lpTarget)+1) * sizeof(WCHAR);
- if (Length > Request->Data.GetConsoleAlias.TargetBufferLength)
+ if (Length > ApiMessage->Data.GetConsoleAlias.TargetBufferLength)
{
ConioUnlockConsole(Console);
return STATUS_BUFFER_TOO_SMALL;
}
- if (!Win32CsrValidateBuffer(ProcessData, lpTarget,
- Request->Data.GetConsoleAlias.TargetBufferLength, 1))
+ if (!Win32CsrValidateBuffer(CsrGetClientThread()->Process, lpTarget,
+ ApiMessage->Data.GetConsoleAlias.TargetBufferLength, 1))
{
ConioUnlockConsole(Console);
return STATUS_ACCESS_VIOLATION;
}
wcscpy(lpTarget, Entry->lpTarget);
- Request->Data.GetConsoleAlias.BytesWritten = Length;
+ ApiMessage->Data.GetConsoleAlias.BytesWritten = Length;
ConioUnlockConsole(Console);
return STATUS_SUCCESS;
}
ULONG BytesWritten;
PALIAS_HEADER Header;
- if (Request->Data.GetAllConsoleAlias.lpExeName == NULL)
+ if (ApiMessage->Data.GetAllConsoleAlias.lpExeName == NULL)
{
return STATUS_INVALID_PARAMETER;
}
- Request->Status = ConioConsoleFromProcessData(ProcessData, &Console);
- if (!NT_SUCCESS(Request->Status))
+ ApiMessage->Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
+ if (!NT_SUCCESS(ApiMessage->Status))
{
- return Request->Status;
+ return ApiMessage->Status;
}
- Header = IntFindAliasHeader(Console->Aliases, Request->Data.GetAllConsoleAlias.lpExeName);
+ Header = IntFindAliasHeader(Console->Aliases, ApiMessage->Data.GetAllConsoleAlias.lpExeName);
if (!Header)
{
ConioUnlockConsole(Console);
return STATUS_INVALID_PARAMETER;
}
- if (IntGetAllConsoleAliasesLength(Header) > Request->Data.GetAllConsoleAlias.AliasBufferLength)
+ if (IntGetAllConsoleAliasesLength(Header) > ApiMessage->Data.GetAllConsoleAlias.AliasBufferLength)
{
ConioUnlockConsole(Console);
return STATUS_BUFFER_OVERFLOW;
}
- if (!Win32CsrValidateBuffer(ProcessData,
- Request->Data.GetAllConsoleAlias.AliasBuffer,
- Request->Data.GetAllConsoleAlias.AliasBufferLength,
+ if (!Win32CsrValidateBuffer(CsrGetClientThread()->Process,
+ ApiMessage->Data.GetAllConsoleAlias.AliasBuffer,
+ ApiMessage->Data.GetAllConsoleAlias.AliasBufferLength,
1))
{
ConioUnlockConsole(Console);
}
BytesWritten = IntGetAllConsoleAliases(Header,
- Request->Data.GetAllConsoleAlias.AliasBuffer,
- Request->Data.GetAllConsoleAlias.AliasBufferLength);
+ ApiMessage->Data.GetAllConsoleAlias.AliasBuffer,
+ ApiMessage->Data.GetAllConsoleAlias.AliasBufferLength);
- Request->Data.GetAllConsoleAlias.BytesWritten = BytesWritten;
+ ApiMessage->Data.GetAllConsoleAlias.BytesWritten = BytesWritten;
ConioUnlockConsole(Console);
return STATUS_SUCCESS;
}
PALIAS_HEADER Header;
UINT Length;
- if (Request->Data.GetAllConsoleAliasesLength.lpExeName == NULL)
+ if (ApiMessage->Data.GetAllConsoleAliasesLength.lpExeName == NULL)
{
return STATUS_INVALID_PARAMETER;
}
- Request->Status = ConioConsoleFromProcessData(ProcessData, &Console);
- if (!NT_SUCCESS(Request->Status))
+ ApiMessage->Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
+ if (!NT_SUCCESS(ApiMessage->Status))
{
- return Request->Status;
+ return ApiMessage->Status;
}
- Header = IntFindAliasHeader(Console->Aliases, Request->Data.GetAllConsoleAliasesLength.lpExeName);
+ Header = IntFindAliasHeader(Console->Aliases, ApiMessage->Data.GetAllConsoleAliasesLength.lpExeName);
if (!Header)
{
ConioUnlockConsole(Console);
}
Length = IntGetAllConsoleAliasesLength(Header);
- Request->Data.GetAllConsoleAliasesLength.Length = Length;
+ ApiMessage->Data.GetAllConsoleAliasesLength.Length = Length;
ConioUnlockConsole(Console);
return STATUS_SUCCESS;
}
DPRINT("CsrGetConsoleAliasesExes entered\n");
- Request->Status = ConioConsoleFromProcessData(ProcessData, &Console);
- if (!NT_SUCCESS(Request->Status))
+ ApiMessage->Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
+ if (!NT_SUCCESS(ApiMessage->Status))
{
- return Request->Status;
+ return ApiMessage->Status;
}
ExesLength = IntGetConsoleAliasesExesLength(Console->Aliases);
- if (ExesLength > Request->Data.GetConsoleAliasesExes.Length)
+ if (ExesLength > ApiMessage->Data.GetConsoleAliasesExes.Length)
{
ConioUnlockConsole(Console);
return STATUS_BUFFER_OVERFLOW;
}
- if (Request->Data.GetConsoleAliasesExes.ExeNames == NULL)
+ if (ApiMessage->Data.GetConsoleAliasesExes.ExeNames == NULL)
{
ConioUnlockConsole(Console);
return STATUS_INVALID_PARAMETER;
}
- if (!Win32CsrValidateBuffer(ProcessData,
- Request->Data.GetConsoleAliasesExes.ExeNames,
- Request->Data.GetConsoleAliasesExes.Length,
+ if (!Win32CsrValidateBuffer(CsrGetClientThread()->Process,
+ ApiMessage->Data.GetConsoleAliasesExes.ExeNames,
+ ApiMessage->Data.GetConsoleAliasesExes.Length,
1))
{
ConioUnlockConsole(Console);
}
BytesWritten = IntGetConsoleAliasesExes(Console->Aliases,
- Request->Data.GetConsoleAliasesExes.ExeNames,
- Request->Data.GetConsoleAliasesExes.Length);
+ ApiMessage->Data.GetConsoleAliasesExes.ExeNames,
+ ApiMessage->Data.GetConsoleAliasesExes.Length);
- Request->Data.GetConsoleAliasesExes.BytesWritten = BytesWritten;
+ ApiMessage->Data.GetConsoleAliasesExes.BytesWritten = BytesWritten;
ConioUnlockConsole(Console);
return STATUS_SUCCESS;
}
PCSRSS_CONSOLE Console;
DPRINT("CsrGetConsoleAliasesExesLength entered\n");
- Request->Status = ConioConsoleFromProcessData(ProcessData, &Console);
- if (NT_SUCCESS(Request->Status))
+ ApiMessage->Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
+ if (NT_SUCCESS(ApiMessage->Status))
{
- Request->Data.GetConsoleAliasesExesLength.Length = IntGetConsoleAliasesExesLength(Console->Aliases);
+ ApiMessage->Data.GetConsoleAliasesExesLength.Length = IntGetConsoleAliasesExesLength(Console->Aliases);
ConioUnlockConsole(Console);
}
- return Request->Status;
+ return ApiMessage->Status;
}
PWCHAR UnicodeBuffer;
ULONG i = 0;
ULONG nNumberOfCharsToRead, CharSize;
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
NTSTATUS Status;
DPRINT("CsrReadConsole\n");
- CharSize = (Request->Data.ReadConsoleRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR));
+ CharSize = (ApiMessage->Data.ReadConsoleRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR));
- nNumberOfCharsToRead = Request->Data.ReadConsoleRequest.NrCharactersToRead;
+ nNumberOfCharsToRead = ApiMessage->Data.ReadConsoleRequest.NrCharactersToRead;
- Buffer = (PCHAR)Request->Data.ReadConsoleRequest.Buffer;
+ Buffer = (PCHAR)ApiMessage->Data.ReadConsoleRequest.Buffer;
UnicodeBuffer = (PWCHAR)Buffer;
if (!Win32CsrValidateBuffer(ProcessData, Buffer, nNumberOfCharsToRead, CharSize))
return STATUS_ACCESS_VIOLATION;
- if (Request->Data.ReadConsoleRequest.NrCharactersRead * sizeof(WCHAR) > nNumberOfCharsToRead * CharSize)
+ if (ApiMessage->Data.ReadConsoleRequest.NrCharactersRead * sizeof(WCHAR) > nNumberOfCharsToRead * CharSize)
return STATUS_INVALID_PARAMETER;
- Status = ConioLockConsole(ProcessData, Request->Data.ReadConsoleRequest.ConsoleHandle,
+ Status = ConioLockConsole(ProcessData, ApiMessage->Data.ReadConsoleRequest.ConsoleHandle,
&Console, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
return Status;
}
- Request->Data.ReadConsoleRequest.EventHandle = ProcessData->ConsoleEvent;
+ ApiMessage->Data.ReadConsoleRequest.EventHandle = ProcessData->ConsoleEvent;
Status = STATUS_PENDING; /* we haven't read anything (yet) */
if (Console->Mode & ENABLE_LINE_INPUT)
Console->LineComplete = FALSE;
Console->LineUpPressed = FALSE;
Console->LineInsertToggle = 0;
- Console->LineWakeupMask = Request->Data.ReadConsoleRequest.CtrlWakeupMask;
- Console->LineSize = Request->Data.ReadConsoleRequest.NrCharactersRead;
+ Console->LineWakeupMask = ApiMessage->Data.ReadConsoleRequest.CtrlWakeupMask;
+ Console->LineSize = ApiMessage->Data.ReadConsoleRequest.NrCharactersRead;
Console->LinePos = Console->LineSize;
/* pre-filling the buffer is only allowed in the Unicode API,
* so we don't need to worry about conversion */
&& Input->InputEvent.Event.KeyEvent.bKeyDown)
{
LineInputKeyDown(Console, &Input->InputEvent.Event.KeyEvent);
- Request->Data.ReadConsoleRequest.ControlKeyState = Input->InputEvent.Event.KeyEvent.dwControlKeyState;
+ ApiMessage->Data.ReadConsoleRequest.ControlKeyState = Input->InputEvent.Event.KeyEvent.dwControlKeyState;
}
HeapFree(Win32CsrApiHeap, 0, Input);
}
while (i < nNumberOfCharsToRead && Console->LinePos != Console->LineSize)
{
WCHAR Char = Console->LineBuffer[Console->LinePos++];
- if (Request->Data.ReadConsoleRequest.Unicode)
+ if (ApiMessage->Data.ReadConsoleRequest.Unicode)
UnicodeBuffer[i++] = Char;
else
ConsoleInputUnicodeCharToAnsiChar(Console, &Buffer[i++], &Char);
&& Input->InputEvent.Event.KeyEvent.uChar.UnicodeChar != L'\0')
{
WCHAR Char = Input->InputEvent.Event.KeyEvent.uChar.UnicodeChar;
- if (Request->Data.ReadConsoleRequest.Unicode)
+ if (ApiMessage->Data.ReadConsoleRequest.Unicode)
UnicodeBuffer[i++] = Char;
else
ConsoleInputUnicodeCharToAnsiChar(Console, &Buffer[i++], &Char);
}
}
done:
- Request->Data.ReadConsoleRequest.NrCharactersRead = i;
+ ApiMessage->Data.ReadConsoleRequest.NrCharactersRead = i;
ConioUnlockConsole(Console);
return Status;
CSR_API(CsrReadInputEvent)
{
PLIST_ENTRY CurrentEntry;
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
NTSTATUS Status;
BOOLEAN Done = FALSE;
DPRINT("CsrReadInputEvent\n");
- Request->Data.ReadInputRequest.Event = ProcessData->ConsoleEvent;
+ ApiMessage->Data.ReadInputRequest.Event = ProcessData->ConsoleEvent;
- Status = ConioLockConsole(ProcessData, Request->Data.ReadInputRequest.ConsoleHandle, &Console, GENERIC_READ);
+ Status = ConioLockConsole(ProcessData, ApiMessage->Data.ReadInputRequest.ConsoleHandle, &Console, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
return Status;
if (Done)
{
- Request->Data.ReadInputRequest.MoreEvents = TRUE;
+ ApiMessage->Data.ReadInputRequest.MoreEvents = TRUE;
break;
}
if (!Done)
{
- Request->Data.ReadInputRequest.Input = Input->InputEvent;
- if (Request->Data.ReadInputRequest.Unicode == FALSE)
+ ApiMessage->Data.ReadInputRequest.Input = Input->InputEvent;
+ if (ApiMessage->Data.ReadInputRequest.Unicode == FALSE)
{
- ConioInputEventToAnsi(Console, &Request->Data.ReadInputRequest.Input);
+ ConioInputEventToAnsi(Console, &ApiMessage->Data.ReadInputRequest.Input);
}
Done = TRUE;
}
DPRINT("CsrFlushInputBuffer\n");
- Status = ConioLockConsole(ProcessData,
- Request->Data.FlushInputBufferRequest.ConsoleInput,
+ Status = ConioLockConsole(CsrGetClientThread()->Process,
+ ApiMessage->Data.FlushInputBufferRequest.ConsoleInput,
&Console,
GENERIC_WRITE);
if(! NT_SUCCESS(Status))
DPRINT("CsrGetNumberOfConsoleInputEvents\n");
- Status = ConioLockConsole(ProcessData, Request->Data.GetNumInputEventsRequest.ConsoleHandle, &Console, GENERIC_READ);
+ Status = ConioLockConsole(CsrGetClientThread()->Process, ApiMessage->Data.GetNumInputEventsRequest.ConsoleHandle, &Console, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
return Status;
ConioUnlockConsole(Console);
- Request->Data.GetNumInputEventsRequest.NumInputEvents = NumEvents;
+ ApiMessage->Data.GetNumInputEventsRequest.NumInputEvents = NumEvents;
return STATUS_SUCCESS;
}
CSR_API(CsrPeekConsoleInput)
{
NTSTATUS Status;
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
DWORD Length;
PLIST_ENTRY CurrentItem;
DPRINT("CsrPeekConsoleInput\n");
- Status = ConioLockConsole(ProcessData, Request->Data.GetNumInputEventsRequest.ConsoleHandle, &Console, GENERIC_READ);
+ Status = ConioLockConsole(ProcessData, ApiMessage->Data.GetNumInputEventsRequest.ConsoleHandle, &Console, GENERIC_READ);
if(! NT_SUCCESS(Status))
{
return Status;
}
- InputRecord = Request->Data.PeekConsoleInputRequest.InputRecord;
- Length = Request->Data.PeekConsoleInputRequest.Length;
+ InputRecord = ApiMessage->Data.PeekConsoleInputRequest.InputRecord;
+ Length = ApiMessage->Data.PeekConsoleInputRequest.Length;
if (!Win32CsrValidateBuffer(ProcessData, InputRecord, Length, sizeof(INPUT_RECORD)))
{
++NumItems;
*InputRecord = Item->InputEvent;
- if (Request->Data.PeekConsoleInputRequest.Unicode == FALSE)
+ if (ApiMessage->Data.PeekConsoleInputRequest.Unicode == FALSE)
{
ConioInputEventToAnsi(Console, InputRecord);
}
ConioUnlockConsole(Console);
- Request->Data.PeekConsoleInputRequest.Length = NumItems;
+ ApiMessage->Data.PeekConsoleInputRequest.Length = NumItems;
return STATUS_SUCCESS;
}
CSR_API(CsrWriteConsoleInput)
{
PINPUT_RECORD InputRecord;
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
NTSTATUS Status;
DWORD Length;
DPRINT("CsrWriteConsoleInput\n");
- Status = ConioLockConsole(ProcessData, Request->Data.WriteConsoleInputRequest.ConsoleHandle, &Console, GENERIC_WRITE);
+ Status = ConioLockConsole(ProcessData, ApiMessage->Data.WriteConsoleInputRequest.ConsoleHandle, &Console, GENERIC_WRITE);
if (! NT_SUCCESS(Status))
{
return Status;
}
- InputRecord = Request->Data.WriteConsoleInputRequest.InputRecord;
- Length = Request->Data.WriteConsoleInputRequest.Length;
+ InputRecord = ApiMessage->Data.WriteConsoleInputRequest.InputRecord;
+ Length = ApiMessage->Data.WriteConsoleInputRequest.Length;
if (!Win32CsrValidateBuffer(ProcessData, InputRecord, Length, sizeof(INPUT_RECORD)))
{
for (i = 0; i < Length && NT_SUCCESS(Status); i++)
{
- if (!Request->Data.WriteConsoleInputRequest.Unicode &&
+ if (!ApiMessage->Data.WriteConsoleInputRequest.Unicode &&
InputRecord->EventType == KEY_EVENT)
{
CHAR AsciiChar = InputRecord->Event.KeyEvent.uChar.AsciiChar;
ConioUnlockConsole(Console);
- Request->Data.WriteConsoleInputRequest.Length = i;
+ ApiMessage->Data.WriteConsoleInputRequest.Length = i;
return Status;
}
NTSTATUS Status;
PCHAR Buffer;
PCSRSS_SCREEN_BUFFER Buff;
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
DWORD Written = 0;
ULONG Length;
- ULONG CharSize = (Request->Data.WriteConsoleRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR));
+ ULONG CharSize = (ApiMessage->Data.WriteConsoleRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR));
DPRINT("CsrWriteConsole\n");
- if (Request->Header.u1.s1.TotalLength
+ if (ApiMessage->Header.u1.s1.TotalLength
< CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE)
- + (Request->Data.WriteConsoleRequest.NrCharactersToWrite * CharSize))
+ + (ApiMessage->Data.WriteConsoleRequest.NrCharactersToWrite * CharSize))
{
- DPRINT1("Invalid request size\n");
+ DPRINT1("Invalid ApiMessage size\n");
return STATUS_INVALID_PARAMETER;
}
- Status = ConioLockScreenBuffer(ProcessData, Request->Data.WriteConsoleRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
+ Status = ConioLockScreenBuffer(ProcessData, ApiMessage->Data.WriteConsoleRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
if (! NT_SUCCESS(Status))
{
return Status;
if (Console->UnpauseEvent)
{
Status = NtDuplicateObject(GetCurrentProcess(), Console->UnpauseEvent,
- ProcessData->ProcessHandle, &Request->Data.WriteConsoleRequest.UnpauseEvent,
+ ProcessData->ProcessHandle, &ApiMessage->Data.WriteConsoleRequest.UnpauseEvent,
SYNCHRONIZE, 0, 0);
ConioUnlockScreenBuffer(Buff);
return NT_SUCCESS(Status) ? STATUS_PENDING : Status;
}
- if(Request->Data.WriteConsoleRequest.Unicode)
+ if(ApiMessage->Data.WriteConsoleRequest.Unicode)
{
Length = WideCharToMultiByte(Console->OutputCodePage, 0,
- (PWCHAR)Request->Data.WriteConsoleRequest.Buffer,
- Request->Data.WriteConsoleRequest.NrCharactersToWrite,
+ (PWCHAR)ApiMessage->Data.WriteConsoleRequest.Buffer,
+ ApiMessage->Data.WriteConsoleRequest.NrCharactersToWrite,
NULL, 0, NULL, NULL);
Buffer = RtlAllocateHeap(GetProcessHeap(), 0, Length);
if (Buffer)
{
WideCharToMultiByte(Console->OutputCodePage, 0,
- (PWCHAR)Request->Data.WriteConsoleRequest.Buffer,
- Request->Data.WriteConsoleRequest.NrCharactersToWrite,
+ (PWCHAR)ApiMessage->Data.WriteConsoleRequest.Buffer,
+ ApiMessage->Data.WriteConsoleRequest.NrCharactersToWrite,
Buffer, Length, NULL, NULL);
}
else
}
else
{
- Buffer = (PCHAR)Request->Data.WriteConsoleRequest.Buffer;
+ Buffer = (PCHAR)ApiMessage->Data.WriteConsoleRequest.Buffer;
}
if (Buffer)
if (NT_SUCCESS(Status))
{
Status = ConioWriteConsole(Console, Buff, Buffer,
- Request->Data.WriteConsoleRequest.NrCharactersToWrite, TRUE);
+ ApiMessage->Data.WriteConsoleRequest.NrCharactersToWrite, TRUE);
if (NT_SUCCESS(Status))
{
- Written = Request->Data.WriteConsoleRequest.NrCharactersToWrite;
+ Written = ApiMessage->Data.WriteConsoleRequest.NrCharactersToWrite;
}
}
- if (Request->Data.WriteConsoleRequest.Unicode)
+ if (ApiMessage->Data.WriteConsoleRequest.Unicode)
{
RtlFreeHeap(GetProcessHeap(), 0, Buffer);
}
}
ConioUnlockScreenBuffer(Buff);
- Request->Data.WriteConsoleRequest.NrCharactersWritten = Written;
+ ApiMessage->Data.WriteConsoleRequest.NrCharactersWritten = Written;
return Status;
}
DPRINT("CsrGetScreenBufferInfo\n");
- Status = ConioLockScreenBuffer(ProcessData, Request->Data.ScreenBufferInfoRequest.ConsoleHandle, &Buff, GENERIC_READ);
+ Status = ConioLockScreenBuffer(CsrGetClientThread()->Process, ApiMessage->Data.ScreenBufferInfoRequest.ConsoleHandle, &Buff, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
return Status;
}
Console = Buff->Header.Console;
- pInfo = &Request->Data.ScreenBufferInfoRequest.Info;
+ pInfo = &ApiMessage->Data.ScreenBufferInfoRequest.Info;
pInfo->dwSize.X = Buff->MaxX;
pInfo->dwSize.Y = Buff->MaxY;
pInfo->dwCursorPosition.X = Buff->CurrentX;
DPRINT("CsrSetCursor\n");
- Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetCursorRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
+ Status = ConioLockScreenBuffer(CsrGetClientThread()->Process, ApiMessage->Data.SetCursorRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
if (! NT_SUCCESS(Status))
{
return Status;
}
Console = Buff->Header.Console;
- NewCursorX = Request->Data.SetCursorRequest.Position.X;
- NewCursorY = Request->Data.SetCursorRequest.Position.Y;
+ NewCursorX = ApiMessage->Data.SetCursorRequest.Position.X;
+ NewCursorY = ApiMessage->Data.SetCursorRequest.Position.Y;
if (NewCursorX < 0 || NewCursorX >= Buff->MaxX ||
NewCursorY < 0 || NewCursorY >= Buff->MaxY)
{
DPRINT("CsrWriteConsoleOutputChar\n");
- CharSize = (Request->Data.WriteConsoleOutputCharRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR));
+ CharSize = (ApiMessage->Data.WriteConsoleOutputCharRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR));
- if (Request->Header.u1.s1.TotalLength
+ if (ApiMessage->Header.u1.s1.TotalLength
< CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_CHAR)
- + (Request->Data.WriteConsoleOutputCharRequest.Length * CharSize))
+ + (ApiMessage->Data.WriteConsoleOutputCharRequest.Length * CharSize))
{
- DPRINT1("Invalid request size\n");
+ DPRINT1("Invalid ApiMessage size\n");
return STATUS_INVALID_PARAMETER;
}
- Status = ConioLockScreenBuffer(ProcessData,
- Request->Data.WriteConsoleOutputCharRequest.ConsoleHandle,
+ Status = ConioLockScreenBuffer(CsrGetClientThread()->Process,
+ ApiMessage->Data.WriteConsoleOutputCharRequest.ConsoleHandle,
&Buff,
GENERIC_WRITE);
if (NT_SUCCESS(Status))
{
Console = Buff->Header.Console;
- if(Request->Data.WriteConsoleOutputCharRequest.Unicode)
+ if(ApiMessage->Data.WriteConsoleOutputCharRequest.Unicode)
{
Length = WideCharToMultiByte(Console->OutputCodePage, 0,
- (PWCHAR)Request->Data.WriteConsoleOutputCharRequest.String,
- Request->Data.WriteConsoleOutputCharRequest.Length,
+ (PWCHAR)ApiMessage->Data.WriteConsoleOutputCharRequest.String,
+ ApiMessage->Data.WriteConsoleOutputCharRequest.Length,
NULL, 0, NULL, NULL);
tmpString = String = RtlAllocateHeap(GetProcessHeap(), 0, Length);
if (String)
{
WideCharToMultiByte(Console->OutputCodePage, 0,
- (PWCHAR)Request->Data.WriteConsoleOutputCharRequest.String,
- Request->Data.WriteConsoleOutputCharRequest.Length,
+ (PWCHAR)ApiMessage->Data.WriteConsoleOutputCharRequest.String,
+ ApiMessage->Data.WriteConsoleOutputCharRequest.Length,
String, Length, NULL, NULL);
}
else
}
else
{
- String = (PCHAR)Request->Data.WriteConsoleOutputCharRequest.String;
+ String = (PCHAR)ApiMessage->Data.WriteConsoleOutputCharRequest.String;
}
if (String)
{
if (NT_SUCCESS(Status))
{
- X = Request->Data.WriteConsoleOutputCharRequest.Coord.X;
- Y = (Request->Data.WriteConsoleOutputCharRequest.Coord.Y + Buff->VirtualY) % Buff->MaxY;
- Length = Request->Data.WriteConsoleOutputCharRequest.Length;
+ X = ApiMessage->Data.WriteConsoleOutputCharRequest.Coord.X;
+ Y = (ApiMessage->Data.WriteConsoleOutputCharRequest.Coord.Y + Buff->VirtualY) % Buff->MaxY;
+ Length = ApiMessage->Data.WriteConsoleOutputCharRequest.Length;
Buffer = &Buff->Buffer[2 * (Y * Buff->MaxX + X)];
while (Length--)
{
}
if (Buff == Console->ActiveBuffer)
{
- ConioComputeUpdateRect(Buff, &UpdateRect, &Request->Data.WriteConsoleOutputCharRequest.Coord,
- Request->Data.WriteConsoleOutputCharRequest.Length);
+ ConioComputeUpdateRect(Buff, &UpdateRect, &ApiMessage->Data.WriteConsoleOutputCharRequest.Coord,
+ ApiMessage->Data.WriteConsoleOutputCharRequest.Length);
ConioDrawRegion(Console, &UpdateRect);
}
- Request->Data.WriteConsoleOutputCharRequest.EndCoord.X = X;
- Request->Data.WriteConsoleOutputCharRequest.EndCoord.Y = (Y + Buff->MaxY - Buff->VirtualY) % Buff->MaxY;
+ ApiMessage->Data.WriteConsoleOutputCharRequest.EndCoord.X = X;
+ ApiMessage->Data.WriteConsoleOutputCharRequest.EndCoord.Y = (Y + Buff->MaxY - Buff->VirtualY) % Buff->MaxY;
}
- if (Request->Data.WriteConsoleRequest.Unicode)
+ if (ApiMessage->Data.WriteConsoleRequest.Unicode)
{
RtlFreeHeap(GetProcessHeap(), 0, tmpString);
}
}
ConioUnlockScreenBuffer(Buff);
}
- Request->Data.WriteConsoleOutputCharRequest.NrCharactersWritten = Written;
+ ApiMessage->Data.WriteConsoleOutputCharRequest.NrCharactersWritten = Written;
return Status;
}
DPRINT("CsrFillOutputChar\n");
- Status = ConioLockScreenBuffer(ProcessData, Request->Data.FillOutputRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
+ Status = ConioLockScreenBuffer(CsrGetClientThread()->Process, ApiMessage->Data.FillOutputRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
if (! NT_SUCCESS(Status))
{
return Status;
}
Console = Buff->Header.Console;
- X = Request->Data.FillOutputRequest.Position.X;
- Y = (Request->Data.FillOutputRequest.Position.Y + Buff->VirtualY) % Buff->MaxY;
+ X = ApiMessage->Data.FillOutputRequest.Position.X;
+ Y = (ApiMessage->Data.FillOutputRequest.Position.Y + Buff->VirtualY) % Buff->MaxY;
Buffer = &Buff->Buffer[2 * (Y * Buff->MaxX + X)];
- if(Request->Data.FillOutputRequest.Unicode)
- ConsoleUnicodeCharToAnsiChar(Console, &Char, &Request->Data.FillOutputRequest.Char.UnicodeChar);
+ if(ApiMessage->Data.FillOutputRequest.Unicode)
+ ConsoleUnicodeCharToAnsiChar(Console, &Char, &ApiMessage->Data.FillOutputRequest.Char.UnicodeChar);
else
- Char = Request->Data.FillOutputRequest.Char.AsciiChar;
- Length = Request->Data.FillOutputRequest.Length;
+ Char = ApiMessage->Data.FillOutputRequest.Char.AsciiChar;
+ Length = ApiMessage->Data.FillOutputRequest.Length;
while (Length--)
{
*Buffer = Char;
if (Buff == Console->ActiveBuffer)
{
- ConioComputeUpdateRect(Buff, &UpdateRect, &Request->Data.FillOutputRequest.Position,
- Request->Data.FillOutputRequest.Length);
+ ConioComputeUpdateRect(Buff, &UpdateRect, &ApiMessage->Data.FillOutputRequest.Position,
+ ApiMessage->Data.FillOutputRequest.Length);
ConioDrawRegion(Console, &UpdateRect);
}
ConioUnlockScreenBuffer(Buff);
- Length = Request->Data.FillOutputRequest.Length;
- Request->Data.FillOutputRequest.NrCharactersWritten = Length;
+ Length = ApiMessage->Data.FillOutputRequest.Length;
+ ApiMessage->Data.FillOutputRequest.NrCharactersWritten = Length;
return STATUS_SUCCESS;
}
DPRINT("CsrWriteConsoleOutputAttrib\n");
- if (Request->Header.u1.s1.TotalLength
+ if (ApiMessage->Header.u1.s1.TotalLength
< CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB)
- + Request->Data.WriteConsoleOutputAttribRequest.Length * sizeof(WORD))
+ + ApiMessage->Data.WriteConsoleOutputAttribRequest.Length * sizeof(WORD))
{
- DPRINT1("Invalid request size\n");
+ DPRINT1("Invalid ApiMessage size\n");
return STATUS_INVALID_PARAMETER;
}
- Status = ConioLockScreenBuffer(ProcessData,
- Request->Data.WriteConsoleOutputAttribRequest.ConsoleHandle,
+ Status = ConioLockScreenBuffer(CsrGetClientThread()->Process,
+ ApiMessage->Data.WriteConsoleOutputAttribRequest.ConsoleHandle,
&Buff,
GENERIC_WRITE);
if (! NT_SUCCESS(Status))
}
Console = Buff->Header.Console;
- X = Request->Data.WriteConsoleOutputAttribRequest.Coord.X;
- Y = (Request->Data.WriteConsoleOutputAttribRequest.Coord.Y + Buff->VirtualY) % Buff->MaxY;
- Length = Request->Data.WriteConsoleOutputAttribRequest.Length;
+ X = ApiMessage->Data.WriteConsoleOutputAttribRequest.Coord.X;
+ Y = (ApiMessage->Data.WriteConsoleOutputAttribRequest.Coord.Y + Buff->VirtualY) % Buff->MaxY;
+ Length = ApiMessage->Data.WriteConsoleOutputAttribRequest.Length;
Buffer = &Buff->Buffer[2 * (Y * Buff->MaxX + X) + 1];
- Attribute = Request->Data.WriteConsoleOutputAttribRequest.Attribute;
+ Attribute = ApiMessage->Data.WriteConsoleOutputAttribRequest.Attribute;
while (Length--)
{
*Buffer = (UCHAR)(*Attribute++);
if (Buff == Console->ActiveBuffer)
{
- ConioComputeUpdateRect(Buff, &UpdateRect, &Request->Data.WriteConsoleOutputAttribRequest.Coord,
- Request->Data.WriteConsoleOutputAttribRequest.Length);
+ ConioComputeUpdateRect(Buff, &UpdateRect, &ApiMessage->Data.WriteConsoleOutputAttribRequest.Coord,
+ ApiMessage->Data.WriteConsoleOutputAttribRequest.Length);
ConioDrawRegion(Console, &UpdateRect);
}
- Request->Data.WriteConsoleOutputAttribRequest.EndCoord.X = X;
- Request->Data.WriteConsoleOutputAttribRequest.EndCoord.Y = (Y + Buff->MaxY - Buff->VirtualY) % Buff->MaxY;
+ ApiMessage->Data.WriteConsoleOutputAttribRequest.EndCoord.X = X;
+ ApiMessage->Data.WriteConsoleOutputAttribRequest.EndCoord.Y = (Y + Buff->MaxY - Buff->VirtualY) % Buff->MaxY;
ConioUnlockScreenBuffer(Buff);
DPRINT("CsrFillOutputAttrib\n");
- Status = ConioLockScreenBuffer(ProcessData, Request->Data.FillOutputAttribRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
+ Status = ConioLockScreenBuffer(CsrGetClientThread()->Process, ApiMessage->Data.FillOutputAttribRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
if (! NT_SUCCESS(Status))
{
return Status;
}
Console = Buff->Header.Console;
- X = Request->Data.FillOutputAttribRequest.Coord.X;
- Y = (Request->Data.FillOutputAttribRequest.Coord.Y + Buff->VirtualY) % Buff->MaxY;
- Length = Request->Data.FillOutputAttribRequest.Length;
- Attr = Request->Data.FillOutputAttribRequest.Attribute;
+ X = ApiMessage->Data.FillOutputAttribRequest.Coord.X;
+ Y = (ApiMessage->Data.FillOutputAttribRequest.Coord.Y + Buff->VirtualY) % Buff->MaxY;
+ Length = ApiMessage->Data.FillOutputAttribRequest.Length;
+ Attr = ApiMessage->Data.FillOutputAttribRequest.Attribute;
Buffer = &Buff->Buffer[(Y * Buff->MaxX * 2) + (X * 2) + 1];
while (Length--)
{
if (Buff == Console->ActiveBuffer)
{
- ConioComputeUpdateRect(Buff, &UpdateRect, &Request->Data.FillOutputAttribRequest.Coord,
- Request->Data.FillOutputAttribRequest.Length);
+ ConioComputeUpdateRect(Buff, &UpdateRect, &ApiMessage->Data.FillOutputAttribRequest.Coord,
+ ApiMessage->Data.FillOutputAttribRequest.Length);
ConioDrawRegion(Console, &UpdateRect);
}
DPRINT("CsrGetCursorInfo\n");
- Status = ConioLockScreenBuffer(ProcessData, Request->Data.GetCursorInfoRequest.ConsoleHandle, &Buff, GENERIC_READ);
+ Status = ConioLockScreenBuffer(CsrGetClientThread()->Process, ApiMessage->Data.GetCursorInfoRequest.ConsoleHandle, &Buff, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
return Status;
}
- Request->Data.GetCursorInfoRequest.Info.bVisible = Buff->CursorInfo.bVisible;
- Request->Data.GetCursorInfoRequest.Info.dwSize = Buff->CursorInfo.dwSize;
+ ApiMessage->Data.GetCursorInfoRequest.Info.bVisible = Buff->CursorInfo.bVisible;
+ ApiMessage->Data.GetCursorInfoRequest.Info.dwSize = Buff->CursorInfo.dwSize;
ConioUnlockScreenBuffer(Buff);
return STATUS_SUCCESS;
DPRINT("CsrSetCursorInfo\n");
- Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetCursorInfoRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
+ Status = ConioLockScreenBuffer(CsrGetClientThread()->Process, ApiMessage->Data.SetCursorInfoRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
if (! NT_SUCCESS(Status))
{
return Status;
}
Console = Buff->Header.Console;
- Size = Request->Data.SetCursorInfoRequest.Info.dwSize;
- Visible = Request->Data.SetCursorInfoRequest.Info.bVisible;
+ Size = ApiMessage->Data.SetCursorInfoRequest.Info.dwSize;
+ Visible = ApiMessage->Data.SetCursorInfoRequest.Info.bVisible;
if (Size < 1)
{
Size = 1;
DPRINT("CsrSetTextAttrib\n");
- Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetCursorRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
+ Status = ConioLockScreenBuffer(CsrGetClientThread()->Process, ApiMessage->Data.SetCursorRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
if (! NT_SUCCESS(Status))
{
return Status;
}
Console = Buff->Header.Console;
- Buff->DefaultAttrib = Request->Data.SetAttribRequest.Attrib;
+ Buff->DefaultAttrib = ApiMessage->Data.SetAttribRequest.Attrib;
if (Buff == Console->ActiveBuffer)
{
if (! ConioUpdateScreenInfo(Console, Buff))
CSR_API(CsrCreateScreenBuffer)
{
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
PCSRSS_SCREEN_BUFFER Buff;
NTSTATUS Status;
if (NT_SUCCESS(Status))
{
Status = Win32CsrInsertObject(ProcessData,
- &Request->Data.CreateScreenBufferRequest.OutputHandle,
+ &ApiMessage->Data.CreateScreenBufferRequest.OutputHandle,
&Buff->Header,
- Request->Data.CreateScreenBufferRequest.Access,
- Request->Data.CreateScreenBufferRequest.Inheritable,
- Request->Data.CreateScreenBufferRequest.ShareMode);
+ ApiMessage->Data.CreateScreenBufferRequest.Access,
+ ApiMessage->Data.CreateScreenBufferRequest.Inheritable,
+ ApiMessage->Data.CreateScreenBufferRequest.ShareMode);
}
}
else
DPRINT("CsrSetScreenBuffer\n");
- Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetScreenBufferRequest.OutputHandle, &Buff, GENERIC_WRITE);
+ Status = ConioLockScreenBuffer(CsrGetClientThread()->Process, ApiMessage->Data.SetScreenBufferRequest.OutputHandle, &Buff, GENERIC_WRITE);
if (! NT_SUCCESS(Status))
{
return Status;
CSR_API(CsrWriteConsoleOutput)
{
SHORT i, X, Y, SizeX, SizeY;
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
PCSRSS_SCREEN_BUFFER Buff;
SMALL_RECT ScreenBuffer;
DPRINT("CsrWriteConsoleOutput\n");
Status = ConioLockScreenBuffer(ProcessData,
- Request->Data.WriteConsoleOutputRequest.ConsoleHandle,
+ ApiMessage->Data.WriteConsoleOutputRequest.ConsoleHandle,
&Buff,
GENERIC_WRITE);
if (! NT_SUCCESS(Status))
}
Console = Buff->Header.Console;
- BufferSize = Request->Data.WriteConsoleOutputRequest.BufferSize;
- BufferCoord = Request->Data.WriteConsoleOutputRequest.BufferCoord;
- CharInfo = Request->Data.WriteConsoleOutputRequest.CharInfo;
+ BufferSize = ApiMessage->Data.WriteConsoleOutputRequest.BufferSize;
+ BufferCoord = ApiMessage->Data.WriteConsoleOutputRequest.BufferCoord;
+ CharInfo = ApiMessage->Data.WriteConsoleOutputRequest.CharInfo;
if (!Win32CsrValidateBuffer(ProcessData, CharInfo,
BufferSize.X * BufferSize.Y, sizeof(CHAR_INFO)))
{
ConioUnlockScreenBuffer(Buff);
return STATUS_ACCESS_VIOLATION;
}
- WriteRegion = Request->Data.WriteConsoleOutputRequest.WriteRegion;
+ WriteRegion = ApiMessage->Data.WriteConsoleOutputRequest.WriteRegion;
SizeY = min(BufferSize.Y - BufferCoord.Y, ConioRectHeight(&WriteRegion));
SizeX = min(BufferSize.X - BufferCoord.X, ConioRectWidth(&WriteRegion));
for (X = WriteRegion.Left; X <= WriteRegion.Right; X++)
{
CHAR AsciiChar;
- if (Request->Data.WriteConsoleOutputRequest.Unicode)
+ if (ApiMessage->Data.WriteConsoleOutputRequest.Unicode)
{
ConsoleUnicodeCharToAnsiChar(Console, &AsciiChar, &CurCharInfo->Char.UnicodeChar);
}
ConioUnlockScreenBuffer(Buff);
- Request->Data.WriteConsoleOutputRequest.WriteRegion.Right = WriteRegion.Left + SizeX - 1;
- Request->Data.WriteConsoleOutputRequest.WriteRegion.Bottom = WriteRegion.Top + SizeY - 1;
- Request->Data.WriteConsoleOutputRequest.WriteRegion.Left = WriteRegion.Left;
- Request->Data.WriteConsoleOutputRequest.WriteRegion.Top = WriteRegion.Top;
+ ApiMessage->Data.WriteConsoleOutputRequest.WriteRegion.Right = WriteRegion.Left + SizeX - 1;
+ ApiMessage->Data.WriteConsoleOutputRequest.WriteRegion.Bottom = WriteRegion.Top + SizeY - 1;
+ ApiMessage->Data.WriteConsoleOutputRequest.WriteRegion.Left = WriteRegion.Left;
+ ApiMessage->Data.WriteConsoleOutputRequest.WriteRegion.Top = WriteRegion.Top;
return STATUS_SUCCESS;
}
DPRINT("CsrScrollConsoleScreenBuffer\n");
- ConsoleHandle = Request->Data.ScrollConsoleScreenBufferRequest.ConsoleHandle;
- UseClipRectangle = Request->Data.ScrollConsoleScreenBufferRequest.UseClipRectangle;
- DestinationOrigin = Request->Data.ScrollConsoleScreenBufferRequest.DestinationOrigin;
- Fill = Request->Data.ScrollConsoleScreenBufferRequest.Fill;
+ ConsoleHandle = ApiMessage->Data.ScrollConsoleScreenBufferRequest.ConsoleHandle;
+ UseClipRectangle = ApiMessage->Data.ScrollConsoleScreenBufferRequest.UseClipRectangle;
+ DestinationOrigin = ApiMessage->Data.ScrollConsoleScreenBufferRequest.DestinationOrigin;
+ Fill = ApiMessage->Data.ScrollConsoleScreenBufferRequest.Fill;
- Status = ConioLockScreenBuffer(ProcessData, ConsoleHandle, &Buff, GENERIC_WRITE);
+ Status = ConioLockScreenBuffer(CsrGetClientThread()->Process, ConsoleHandle, &Buff, GENERIC_WRITE);
if (! NT_SUCCESS(Status))
{
return Status;
}
Console = Buff->Header.Console;
- ScrollRectangle = Request->Data.ScrollConsoleScreenBufferRequest.ScrollRectangle;
+ ScrollRectangle = ApiMessage->Data.ScrollConsoleScreenBufferRequest.ScrollRectangle;
/* Make sure source rectangle is inside the screen buffer */
ConioInitRect(&ScreenBuffer, 0, 0, Buff->MaxY - 1, Buff->MaxX - 1);
if (UseClipRectangle)
{
- ClipRectangle = Request->Data.ScrollConsoleScreenBufferRequest.ClipRectangle;
+ ClipRectangle = ApiMessage->Data.ScrollConsoleScreenBufferRequest.ClipRectangle;
if (!ConioGetIntersection(&ClipRectangle, &ClipRectangle, &ScreenBuffer))
{
ConioUnlockScreenBuffer(Buff);
DestinationOrigin.Y + ConioRectHeight(&SrcRegion) - 1,
DestinationOrigin.X + ConioRectWidth(&SrcRegion) - 1);
- if (Request->Data.ScrollConsoleScreenBufferRequest.Unicode)
+ if (ApiMessage->Data.ScrollConsoleScreenBufferRequest.Unicode)
ConsoleUnicodeCharToAnsiChar(Console, &FillChar, &Fill.Char.UnicodeChar);
else
FillChar = Fill.Char.AsciiChar;
DPRINT("CsrReadConsoleOutputChar\n");
- ReadBuffer = Request->Data.ReadConsoleOutputCharRequest.String;
+ ReadBuffer = ApiMessage->Data.ReadConsoleOutputCharRequest.String;
- CharSize = (Request->Data.ReadConsoleOutputCharRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR));
+ CharSize = (ApiMessage->Data.ReadConsoleOutputCharRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR));
- Status = ConioLockScreenBuffer(ProcessData, Request->Data.ReadConsoleOutputCharRequest.ConsoleHandle, &Buff, GENERIC_READ);
+ Status = ConioLockScreenBuffer(CsrGetClientThread()->Process, ApiMessage->Data.ReadConsoleOutputCharRequest.ConsoleHandle, &Buff, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
return Status;
}
Console = Buff->Header.Console;
- Xpos = Request->Data.ReadConsoleOutputCharRequest.ReadCoord.X;
- Ypos = (Request->Data.ReadConsoleOutputCharRequest.ReadCoord.Y + Buff->VirtualY) % Buff->MaxY;
+ Xpos = ApiMessage->Data.ReadConsoleOutputCharRequest.ReadCoord.X;
+ Ypos = (ApiMessage->Data.ReadConsoleOutputCharRequest.ReadCoord.Y + Buff->VirtualY) % Buff->MaxY;
- for (i = 0; i < Request->Data.ReadConsoleOutputCharRequest.NumCharsToRead; ++i)
+ for (i = 0; i < ApiMessage->Data.ReadConsoleOutputCharRequest.NumCharsToRead; ++i)
{
Char = Buff->Buffer[(Xpos * 2) + (Ypos * 2 * Buff->MaxX)];
- if(Request->Data.ReadConsoleOutputCharRequest.Unicode)
+ if(ApiMessage->Data.ReadConsoleOutputCharRequest.Unicode)
{
ConsoleAnsiCharToUnicodeChar(Console, (WCHAR*)ReadBuffer, &Char);
ReadBuffer += sizeof(WCHAR);
}
*ReadBuffer = 0;
- Request->Data.ReadConsoleOutputCharRequest.EndCoord.X = Xpos;
- Request->Data.ReadConsoleOutputCharRequest.EndCoord.Y = (Ypos - Buff->VirtualY + Buff->MaxY) % Buff->MaxY;
+ ApiMessage->Data.ReadConsoleOutputCharRequest.EndCoord.X = Xpos;
+ ApiMessage->Data.ReadConsoleOutputCharRequest.EndCoord.Y = (Ypos - Buff->VirtualY + Buff->MaxY) % Buff->MaxY;
ConioUnlockScreenBuffer(Buff);
- Request->Data.ReadConsoleOutputCharRequest.CharsRead = (DWORD)((ULONG_PTR)ReadBuffer - (ULONG_PTR)Request->Data.ReadConsoleOutputCharRequest.String) / CharSize;
- if (Request->Data.ReadConsoleOutputCharRequest.CharsRead * CharSize + CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_CHAR) > sizeof(CSR_API_MESSAGE))
+ ApiMessage->Data.ReadConsoleOutputCharRequest.CharsRead = (DWORD)((ULONG_PTR)ReadBuffer - (ULONG_PTR)ApiMessage->Data.ReadConsoleOutputCharRequest.String) / CharSize;
+ if (ApiMessage->Data.ReadConsoleOutputCharRequest.CharsRead * CharSize + CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_CHAR) > sizeof(CSR_API_MESSAGE))
{
DPRINT1("Length won't fit in message\n");
return STATUS_BUFFER_TOO_SMALL;
DPRINT("CsrReadConsoleOutputAttrib\n");
- ReadBuffer = Request->Data.ReadConsoleOutputAttribRequest.Attribute;
+ ReadBuffer = ApiMessage->Data.ReadConsoleOutputAttribRequest.Attribute;
- Status = ConioLockScreenBuffer(ProcessData, Request->Data.ReadConsoleOutputAttribRequest.ConsoleHandle, &Buff, GENERIC_READ);
+ Status = ConioLockScreenBuffer(CsrGetClientThread()->Process, ApiMessage->Data.ReadConsoleOutputAttribRequest.ConsoleHandle, &Buff, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
return Status;
}
- Xpos = Request->Data.ReadConsoleOutputAttribRequest.ReadCoord.X;
- Ypos = (Request->Data.ReadConsoleOutputAttribRequest.ReadCoord.Y + Buff->VirtualY) % Buff->MaxY;
+ Xpos = ApiMessage->Data.ReadConsoleOutputAttribRequest.ReadCoord.X;
+ Ypos = (ApiMessage->Data.ReadConsoleOutputAttribRequest.ReadCoord.Y + Buff->VirtualY) % Buff->MaxY;
- for (i = 0; i < Request->Data.ReadConsoleOutputAttribRequest.NumAttrsToRead; ++i)
+ for (i = 0; i < ApiMessage->Data.ReadConsoleOutputAttribRequest.NumAttrsToRead; ++i)
{
*ReadBuffer = Buff->Buffer[(Xpos * 2) + (Ypos * 2 * Buff->MaxX) + 1];
*ReadBuffer = 0;
- Request->Data.ReadConsoleOutputAttribRequest.EndCoord.X = Xpos;
- Request->Data.ReadConsoleOutputAttribRequest.EndCoord.Y = (Ypos - Buff->VirtualY + Buff->MaxY) % Buff->MaxY;
+ ApiMessage->Data.ReadConsoleOutputAttribRequest.EndCoord.X = Xpos;
+ ApiMessage->Data.ReadConsoleOutputAttribRequest.EndCoord.Y = (Ypos - Buff->VirtualY + Buff->MaxY) % Buff->MaxY;
ConioUnlockScreenBuffer(Buff);
CurrentLength = CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_ATTRIB)
- + Request->Data.ReadConsoleOutputAttribRequest.NumAttrsToRead * sizeof(WORD);
+ + ApiMessage->Data.ReadConsoleOutputAttribRequest.NumAttrsToRead * sizeof(WORD);
if (CurrentLength > sizeof(CSR_API_MESSAGE))
{
DPRINT1("Length won't fit in message\n");
CSR_API(CsrReadConsoleOutput)
{
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCHAR_INFO CharInfo;
PCHAR_INFO CurCharInfo;
PCSRSS_SCREEN_BUFFER Buff;
DPRINT("CsrReadConsoleOutput\n");
- Status = ConioLockScreenBuffer(ProcessData, Request->Data.ReadConsoleOutputRequest.ConsoleHandle, &Buff, GENERIC_READ);
+ Status = ConioLockScreenBuffer(ProcessData, ApiMessage->Data.ReadConsoleOutputRequest.ConsoleHandle, &Buff, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
return Status;
}
- CharInfo = Request->Data.ReadConsoleOutputRequest.CharInfo;
- ReadRegion = Request->Data.ReadConsoleOutputRequest.ReadRegion;
- BufferSize = Request->Data.ReadConsoleOutputRequest.BufferSize;
- BufferCoord = Request->Data.ReadConsoleOutputRequest.BufferCoord;
+ CharInfo = ApiMessage->Data.ReadConsoleOutputRequest.CharInfo;
+ ReadRegion = ApiMessage->Data.ReadConsoleOutputRequest.ReadRegion;
+ BufferSize = ApiMessage->Data.ReadConsoleOutputRequest.BufferSize;
+ BufferCoord = ApiMessage->Data.ReadConsoleOutputRequest.BufferCoord;
/* FIXME: Is this correct? */
CodePage = ProcessData->Console->OutputCodePage;
Ptr = ConioCoordToPointer(Buff, ReadRegion.Left, Y);
for (X = ReadRegion.Left; X < ReadRegion.Right; ++X)
{
- if (Request->Data.ReadConsoleOutputRequest.Unicode)
+ if (ApiMessage->Data.ReadConsoleOutputRequest.Unicode)
{
MultiByteToWideChar(CodePage, 0,
(PCHAR)Ptr++, 1,
ConioUnlockScreenBuffer(Buff);
- Request->Data.ReadConsoleOutputRequest.ReadRegion.Right = ReadRegion.Left + SizeX - 1;
- Request->Data.ReadConsoleOutputRequest.ReadRegion.Bottom = ReadRegion.Top + SizeY - 1;
- Request->Data.ReadConsoleOutputRequest.ReadRegion.Left = ReadRegion.Left;
- Request->Data.ReadConsoleOutputRequest.ReadRegion.Top = ReadRegion.Top;
+ ApiMessage->Data.ReadConsoleOutputRequest.ReadRegion.Right = ReadRegion.Left + SizeX - 1;
+ ApiMessage->Data.ReadConsoleOutputRequest.ReadRegion.Bottom = ReadRegion.Top + SizeY - 1;
+ ApiMessage->Data.ReadConsoleOutputRequest.ReadRegion.Left = ReadRegion.Left;
+ ApiMessage->Data.ReadConsoleOutputRequest.ReadRegion.Top = ReadRegion.Top;
return STATUS_SUCCESS;
}
PCSRSS_CONSOLE Console;
PCSRSS_SCREEN_BUFFER Buff;
- Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetScreenBufferSize.OutputHandle, &Buff, GENERIC_WRITE);
+ Status = ConioLockScreenBuffer(CsrGetClientThread()->Process, ApiMessage->Data.SetScreenBufferSize.OutputHandle, &Buff, GENERIC_WRITE);
if (!NT_SUCCESS(Status))
{
return Status;
}
Console = Buff->Header.Console;
- Status = ConioResizeBuffer(Console, Buff, Request->Data.SetScreenBufferSize.Size);
+ Status = ConioResizeBuffer(Console, Buff, ApiMessage->Data.SetScreenBufferSize.Size);
ConioUnlockScreenBuffer(Buff);
return Status;
CSR_API(CsrAllocConsole)
{
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
NTSTATUS Status = STATUS_SUCCESS;
BOOLEAN NewConsole = FALSE;
}
/* If we don't need a console, then get out of here */
- if (!Request->Data.AllocConsoleRequest.ConsoleNeeded)
+ if (!ApiMessage->Data.AllocConsoleRequest.ConsoleNeeded)
{
DPRINT("No console needed\n");
RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
}
/* If we already have one, then don't create a new one... */
- if (!Request->Data.AllocConsoleRequest.Console ||
- Request->Data.AllocConsoleRequest.Console != ProcessData->ParentConsole)
+ if (!ApiMessage->Data.AllocConsoleRequest.Console ||
+ ApiMessage->Data.AllocConsoleRequest.Console != ProcessData->ParentConsole)
{
/* Allocate a console structure */
NewConsole = TRUE;
/* insert process data required for GUI initialization */
InsertHeadList(&Console->ProcessList, &ProcessData->ConsoleLink);
/* Initialize the Console */
- Status = CsrInitConsole(Console, Request->Data.AllocConsoleRequest.ShowCmd);
+ Status = CsrInitConsole(Console, ApiMessage->Data.AllocConsoleRequest.ShowCmd);
if (!NT_SUCCESS(Status))
{
DPRINT1("Console init failed\n");
else
{
/* Reuse our current console */
- Console = Request->Data.AllocConsoleRequest.Console;
+ Console = ApiMessage->Data.AllocConsoleRequest.Console;
}
/* Set the Process Console */
ProcessData->Console = Console;
/* Return it to the caller */
- Request->Data.AllocConsoleRequest.Console = Console;
+ ApiMessage->Data.AllocConsoleRequest.Console = Console;
/* Add a reference count because the process is tied to the console */
_InterlockedIncrement(&Console->ReferenceCount);
{
/* Insert the Objects */
Status = Win32CsrInsertObject(ProcessData,
- &Request->Data.AllocConsoleRequest.InputHandle,
+ &ApiMessage->Data.AllocConsoleRequest.InputHandle,
&Console->Header,
GENERIC_READ | GENERIC_WRITE,
TRUE,
}
Status = Win32CsrInsertObject(ProcessData,
- &Request->Data.AllocConsoleRequest.OutputHandle,
+ &ApiMessage->Data.AllocConsoleRequest.OutputHandle,
&Console->ActiveBuffer->Header,
GENERIC_READ | GENERIC_WRITE,
TRUE,
DPRINT1("Failed to insert object\n");
ConioDeleteConsole((Object_t *) Console);
Win32CsrReleaseObject(ProcessData,
- Request->Data.AllocConsoleRequest.InputHandle);
+ ApiMessage->Data.AllocConsoleRequest.InputHandle);
ProcessData->Console = 0;
RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
return Status;
if (NewConsole || !ProcessData->bInheritHandles)
{
Win32CsrReleaseObject(ProcessData,
- Request->Data.AllocConsoleRequest.OutputHandle);
+ ApiMessage->Data.AllocConsoleRequest.OutputHandle);
Win32CsrReleaseObject(ProcessData,
- Request->Data.AllocConsoleRequest.InputHandle);
+ ApiMessage->Data.AllocConsoleRequest.InputHandle);
}
ProcessData->Console = 0;
RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
}
/* Set the Ctrl Dispatcher */
- ProcessData->CtrlDispatcher = Request->Data.AllocConsoleRequest.CtrlDispatcher;
+ ProcessData->CtrlDispatcher = ApiMessage->Data.AllocConsoleRequest.CtrlDispatcher;
DPRINT("CSRSS:CtrlDispatcher address: %x\n", ProcessData->CtrlDispatcher);
if (!NewConsole)
CSR_API(CsrFreeConsole)
{
- Win32CsrReleaseConsole(ProcessData);
+ Win32CsrReleaseConsole(CsrGetClientThread()->Process);
return STATUS_SUCCESS;
}
DPRINT("CsrSetConsoleMode\n");
- Status = Win32CsrLockObject(ProcessData,
- Request->Data.SetConsoleModeRequest.ConsoleHandle,
+ Status = Win32CsrLockObject(CsrGetClientThread()->Process,
+ ApiMessage->Data.SetConsoleModeRequest.ConsoleHandle,
(Object_t **) &Console, GENERIC_WRITE, 0);
if (! NT_SUCCESS(Status))
{
Buff = (PCSRSS_SCREEN_BUFFER)Console;
if (CONIO_CONSOLE_MAGIC == Console->Header.Type)
{
- Console->Mode = Request->Data.SetConsoleModeRequest.Mode & CONSOLE_INPUT_MODE_VALID;
+ Console->Mode = ApiMessage->Data.SetConsoleModeRequest.Mode & CONSOLE_INPUT_MODE_VALID;
}
else if (CONIO_SCREEN_BUFFER_MAGIC == Console->Header.Type)
{
- Buff->Mode = Request->Data.SetConsoleModeRequest.Mode & CONSOLE_OUTPUT_MODE_VALID;
+ Buff->Mode = ApiMessage->Data.SetConsoleModeRequest.Mode & CONSOLE_OUTPUT_MODE_VALID;
}
else
{
DPRINT("CsrGetConsoleMode\n");
- Status = Win32CsrLockObject(ProcessData, Request->Data.GetConsoleModeRequest.ConsoleHandle,
+ Status = Win32CsrLockObject(CsrGetClientThread()->Process, ApiMessage->Data.GetConsoleModeRequest.ConsoleHandle,
(Object_t **) &Console, GENERIC_READ, 0);
if (! NT_SUCCESS(Status))
{
Buff = (PCSRSS_SCREEN_BUFFER) Console;
if (CONIO_CONSOLE_MAGIC == Console->Header.Type)
{
- Request->Data.GetConsoleModeRequest.ConsoleMode = Console->Mode;
+ ApiMessage->Data.GetConsoleModeRequest.ConsoleMode = Console->Mode;
}
else if (CONIO_SCREEN_BUFFER_MAGIC == Buff->Header.Type)
{
- Request->Data.GetConsoleModeRequest.ConsoleMode = Buff->Mode;
+ ApiMessage->Data.GetConsoleModeRequest.ConsoleMode = Buff->Mode;
}
else
{
CSR_API(CsrSetTitle)
{
NTSTATUS Status;
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
PWCHAR Buffer;
DPRINT("CsrSetTitle\n");
- if (!Win32CsrValidateBuffer(ProcessData, Request->Data.SetTitleRequest.Title,
- Request->Data.SetTitleRequest.Length, 1))
+ if (!Win32CsrValidateBuffer(ProcessData, ApiMessage->Data.SetTitleRequest.Title,
+ ApiMessage->Data.SetTitleRequest.Length, 1))
{
return STATUS_ACCESS_VIOLATION;
}
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if(NT_SUCCESS(Status))
{
- Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, Request->Data.SetTitleRequest.Length);
+ Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, ApiMessage->Data.SetTitleRequest.Length);
if (Buffer)
{
/* copy title to console */
RtlFreeUnicodeString(&Console->Title);
Console->Title.Buffer = Buffer;
- Console->Title.Length = Console->Title.MaximumLength = Request->Data.SetTitleRequest.Length;
- memcpy(Console->Title.Buffer, Request->Data.SetTitleRequest.Title, Console->Title.Length);
+ Console->Title.Length = Console->Title.MaximumLength = ApiMessage->Data.SetTitleRequest.Length;
+ memcpy(Console->Title.Buffer, ApiMessage->Data.SetTitleRequest.Title, Console->Title.Length);
if (! ConioChangeTitle(Console))
{
Status = STATUS_UNSUCCESSFUL;
CSR_API(CsrGetTitle)
{
NTSTATUS Status;
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
DWORD Length;
DPRINT("CsrGetTitle\n");
- if (!Win32CsrValidateBuffer(ProcessData, Request->Data.GetTitleRequest.Title,
- Request->Data.GetTitleRequest.Length, 1))
+ if (!Win32CsrValidateBuffer(ProcessData, ApiMessage->Data.GetTitleRequest.Title,
+ ApiMessage->Data.GetTitleRequest.Length, 1))
{
return STATUS_ACCESS_VIOLATION;
}
}
/* Copy title of the console to the user title buffer */
- if (Request->Data.GetTitleRequest.Length >= sizeof(WCHAR))
+ if (ApiMessage->Data.GetTitleRequest.Length >= sizeof(WCHAR))
{
- Length = min(Request->Data.GetTitleRequest.Length - sizeof(WCHAR), Console->Title.Length);
- memcpy(Request->Data.GetTitleRequest.Title, Console->Title.Buffer, Length);
- Request->Data.GetTitleRequest.Title[Length / sizeof(WCHAR)] = L'\0';
+ Length = min(ApiMessage->Data.GetTitleRequest.Length - sizeof(WCHAR), Console->Title.Length);
+ memcpy(ApiMessage->Data.GetTitleRequest.Title, Console->Title.Buffer, Length);
+ ApiMessage->Data.GetTitleRequest.Title[Length / sizeof(WCHAR)] = L'\0';
}
- Request->Data.GetTitleRequest.Length = Console->Title.Length;
+ ApiMessage->Data.GetTitleRequest.Length = Console->Title.Length;
ConioUnlockConsole(Console);
return STATUS_SUCCESS;
DPRINT("CsrHardwareStateProperty\n");
- Status = ConioLockConsole(ProcessData,
- Request->Data.ConsoleHardwareStateRequest.ConsoleHandle,
+ Status = ConioLockConsole(CsrGetClientThread()->Process,
+ ApiMessage->Data.ConsoleHardwareStateRequest.ConsoleHandle,
&Console,
GENERIC_READ);
if (! NT_SUCCESS(Status))
return Status;
}
- switch (Request->Data.ConsoleHardwareStateRequest.SetGet)
+ switch (ApiMessage->Data.ConsoleHardwareStateRequest.SetGet)
{
case CONSOLE_HARDWARE_STATE_GET:
- Request->Data.ConsoleHardwareStateRequest.State = Console->HardwareState;
+ ApiMessage->Data.ConsoleHardwareStateRequest.State = Console->HardwareState;
break;
case CONSOLE_HARDWARE_STATE_SET:
DPRINT("Setting console hardware state.\n");
- Status = SetConsoleHardwareState(Console, Request->Data.ConsoleHardwareStateRequest.State);
+ Status = SetConsoleHardwareState(Console, ApiMessage->Data.ConsoleHardwareStateRequest.State);
break;
default:
DPRINT("CsrGetConsoleWindow\n");
- Status = ConioConsoleFromProcessData(ProcessData, &Console);
+ Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
if (! NT_SUCCESS(Status))
{
return Status;
}
- Request->Data.GetConsoleWindowRequest.WindowHandle = Console->hWindow;
+ ApiMessage->Data.GetConsoleWindowRequest.WindowHandle = Console->hWindow;
ConioUnlockConsole(Console);
return STATUS_SUCCESS;
DPRINT("CsrSetConsoleIcon\n");
- Status = ConioConsoleFromProcessData(ProcessData, &Console);
+ Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
if (! NT_SUCCESS(Status))
{
return Status;
}
- Status = (ConioChangeIcon(Console, Request->Data.SetConsoleIconRequest.WindowIcon)
+ Status = (ConioChangeIcon(Console, ApiMessage->Data.SetConsoleIconRequest.WindowIcon)
? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
ConioUnlockConsole(Console);
DPRINT("CsrGetConsoleCodePage\n");
- Status = ConioConsoleFromProcessData(ProcessData, &Console);
+ Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
if (! NT_SUCCESS(Status))
{
return Status;
}
- Request->Data.GetConsoleCodePage.CodePage = Console->CodePage;
+ ApiMessage->Data.GetConsoleCodePage.CodePage = Console->CodePage;
ConioUnlockConsole(Console);
return STATUS_SUCCESS;
}
DPRINT("CsrSetConsoleCodePage\n");
- Status = ConioConsoleFromProcessData(ProcessData, &Console);
+ Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
if (! NT_SUCCESS(Status))
{
return Status;
}
- if (IsValidCodePage(Request->Data.SetConsoleCodePage.CodePage))
+ if (IsValidCodePage(ApiMessage->Data.SetConsoleCodePage.CodePage))
{
- Console->CodePage = Request->Data.SetConsoleCodePage.CodePage;
+ Console->CodePage = ApiMessage->Data.SetConsoleCodePage.CodePage;
ConioUnlockConsole(Console);
return STATUS_SUCCESS;
}
DPRINT("CsrGetConsoleOutputCodePage\n");
- Status = ConioConsoleFromProcessData(ProcessData, &Console);
+ Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
if (! NT_SUCCESS(Status))
{
return Status;
}
- Request->Data.GetConsoleOutputCodePage.CodePage = Console->OutputCodePage;
+ ApiMessage->Data.GetConsoleOutputCodePage.CodePage = Console->OutputCodePage;
ConioUnlockConsole(Console);
return STATUS_SUCCESS;
}
DPRINT("CsrSetConsoleOutputCodePage\n");
- Status = ConioConsoleFromProcessData(ProcessData, &Console);
+ Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
if (! NT_SUCCESS(Status))
{
return Status;
}
- if (IsValidCodePage(Request->Data.SetConsoleOutputCodePage.CodePage))
+ if (IsValidCodePage(ApiMessage->Data.SetConsoleOutputCodePage.CodePage))
{
- Console->OutputCodePage = Request->Data.SetConsoleOutputCodePage.CodePage;
+ Console->OutputCodePage = ApiMessage->Data.SetConsoleOutputCodePage.CodePage;
ConioUnlockConsole(Console);
return STATUS_SUCCESS;
}
CSR_API(CsrGetProcessList)
{
PDWORD Buffer;
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
PCSR_PROCESS current;
PLIST_ENTRY current_entry;
DPRINT("CsrGetProcessList\n");
- Buffer = Request->Data.GetProcessListRequest.ProcessId;
- if (!Win32CsrValidateBuffer(ProcessData, Buffer, Request->Data.GetProcessListRequest.nMaxIds, sizeof(DWORD)))
+ Buffer = ApiMessage->Data.GetProcessListRequest.ProcessId;
+ if (!Win32CsrValidateBuffer(ProcessData, Buffer, ApiMessage->Data.GetProcessListRequest.nMaxIds, sizeof(DWORD)))
return STATUS_ACCESS_VIOLATION;
Status = ConioConsoleFromProcessData(ProcessData, &Console);
current_entry = current_entry->Flink)
{
current = CONTAINING_RECORD(current_entry, CSR_PROCESS, ConsoleLink);
- if (++nItems <= Request->Data.GetProcessListRequest.nMaxIds)
+ if (++nItems <= ApiMessage->Data.GetProcessListRequest.nMaxIds)
{
*Buffer++ = HandleToUlong(current->ClientId.UniqueProcess);
}
ConioUnlockConsole(Console);
- Request->Data.GetProcessListRequest.nProcessIdsTotal = nItems;
+ ApiMessage->Data.GetProcessListRequest.nProcessIdsTotal = nItems;
return STATUS_SUCCESS;
}
DWORD Group;
NTSTATUS Status;
- Status = ConioConsoleFromProcessData(ProcessData, &Console);
+ Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
if (! NT_SUCCESS(Status))
{
return Status;
}
- Group = Request->Data.GenerateCtrlEvent.ProcessGroup;
+ Group = ApiMessage->Data.GenerateCtrlEvent.ProcessGroup;
Status = STATUS_INVALID_PARAMETER;
for (current_entry = Console->ProcessList.Flink;
current_entry != &Console->ProcessList;
current = CONTAINING_RECORD(current_entry, CSR_PROCESS, ConsoleLink);
if (Group == 0 || current->ProcessGroupId == Group)
{
- ConioConsoleCtrlEvent(Request->Data.GenerateCtrlEvent.Event, current);
+ ConioConsoleCtrlEvent(ApiMessage->Data.GenerateCtrlEvent.Event, current);
Status = STATUS_SUCCESS;
}
}
NTSTATUS Status;
PCSRSS_CONSOLE Console;
- Status = ConioConsoleFromProcessData(ProcessData, &Console);
+ Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
if (NT_SUCCESS(Status))
{
- memset(&Request->Data.GetConsoleSelectionInfo.Info, 0, sizeof(CONSOLE_SELECTION_INFO));
+ memset(&ApiMessage->Data.GetConsoleSelectionInfo.Info, 0, sizeof(CONSOLE_SELECTION_INFO));
if (Console->Selection.dwFlags != 0)
- Request->Data.GetConsoleSelectionInfo.Info = Console->Selection;
+ ApiMessage->Data.GetConsoleSelectionInfo.Info = Console->Selection;
ConioUnlockConsole(Console);
}
return Status;
* The desktop handle we got from win32k is in
* the scope of CSRSS so we can just use it.
*/
- ThreadData.Desktop = Request->Data.CreateDesktopRequest.DesktopHandle;
+ ThreadData.Desktop = ApiMessage->Data.CreateDesktopRequest.DesktopHandle;
ThreadData.Event = CreateEventW(NULL, FALSE, FALSE, NULL);
PRIVATE_NOTIFY_DESKTOP nmh;
DPRINT("CsrShowDesktop\n");
- nmh.hdr.hwndFrom = Request->Data.ShowDesktopRequest.DesktopWindow;
+ nmh.hdr.hwndFrom = ApiMessage->Data.ShowDesktopRequest.DesktopWindow;
nmh.hdr.idFrom = 0;
nmh.hdr.code = PM_SHOW_DESKTOP;
- nmh.ShowDesktop.Width = (int)Request->Data.ShowDesktopRequest.Width;
- nmh.ShowDesktop.Height = (int)Request->Data.ShowDesktopRequest.Height;
+ nmh.ShowDesktop.Width = (int)ApiMessage->Data.ShowDesktopRequest.Width;
+ nmh.ShowDesktop.Height = (int)ApiMessage->Data.ShowDesktopRequest.Height;
- if (SendMessageW(Request->Data.ShowDesktopRequest.DesktopWindow,
+ if (SendMessageW(ApiMessage->Data.ShowDesktopRequest.DesktopWindow,
WM_NOTIFY,
(WPARAM)nmh.hdr.hwndFrom,
(LPARAM)&nmh))
PRIVATE_NOTIFY_DESKTOP nmh;
DPRINT("CsrHideDesktop\n");
- nmh.hdr.hwndFrom = Request->Data.ShowDesktopRequest.DesktopWindow;
+ nmh.hdr.hwndFrom = ApiMessage->Data.ShowDesktopRequest.DesktopWindow;
nmh.hdr.idFrom = 0;
nmh.hdr.code = PM_HIDE_DESKTOP;
- if (SendMessageW(Request->Data.ShowDesktopRequest.DesktopWindow,
+ if (SendMessageW(ApiMessage->Data.ShowDesktopRequest.DesktopWindow,
WM_NOTIFY,
(WPARAM)nmh.hdr.hwndFrom,
(LPARAM)&nmh))
CSR_API(CsrRegisterLogonProcess)
{
- if (Request->Data.RegisterLogonProcessRequest.Register)
+ if (ApiMessage->Data.RegisterLogonProcessRequest.Register)
{
if (0 != LogonProcess)
{
return STATUS_LOGON_SESSION_EXISTS;
}
- LogonProcess = Request->Data.RegisterLogonProcessRequest.ProcessId;
+ LogonProcess = ApiMessage->Data.RegisterLogonProcessRequest.ProcessId;
}
else
{
- if (Request->Header.ClientId.UniqueProcess != LogonProcess)
+ if (ApiMessage->Header.ClientId.UniqueProcess != LogonProcess)
{
DPRINT1("Current logon process 0x%x, can't deregister from process 0x%x\n",
- LogonProcess, Request->Header.ClientId.UniqueProcess);
+ LogonProcess, ApiMessage->Header.ClientId.UniqueProcess);
return STATUS_NOT_LOGON_PROCESS;
}
LogonProcess = 0;
{
DWORD WindowCreator;
- if (0 == GetWindowThreadProcessId(Request->Data.SetLogonNotifyWindowRequest.LogonNotifyWindow,
+ if (0 == GetWindowThreadProcessId(ApiMessage->Data.SetLogonNotifyWindowRequest.LogonNotifyWindow,
&WindowCreator))
{
DPRINT1("Can't get window creator\n");
return STATUS_ACCESS_DENIED;
}
- LogonNotifyWindow = Request->Data.SetLogonNotifyWindowRequest.LogonNotifyWindow;
+ LogonNotifyWindow = ApiMessage->Data.SetLogonNotifyWindowRequest.LogonNotifyWindow;
return STATUS_SUCCESS;
}
CSR_API(CsrExitReactos)
{
- if (0 == (Request->Data.ExitReactosRequest.Flags & EWX_INTERNAL_FLAG))
+ if (0 == (ApiMessage->Data.ExitReactosRequest.Flags & EWX_INTERNAL_FLAG))
{
- return UserExitReactos((DWORD_PTR) Request->Header.ClientId.UniqueProcess,
- Request->Data.ExitReactosRequest.Flags);
+ return UserExitReactos((DWORD_PTR) ApiMessage->Header.ClientId.UniqueProcess,
+ ApiMessage->Data.ExitReactosRequest.Flags);
}
else
{
- return InternalExitReactos((DWORD_PTR) Request->Header.ClientId.UniqueProcess,
- (DWORD_PTR) Request->Header.ClientId.UniqueThread,
- Request->Data.ExitReactosRequest.Flags);
+ return InternalExitReactos((DWORD_PTR) ApiMessage->Header.ClientId.UniqueProcess,
+ (DWORD_PTR) ApiMessage->Header.ClientId.UniqueThread,
+ ApiMessage->Data.ExitReactosRequest.Flags);
}
}
DPRINT("CsrGetTempFile entered\n");
/* Return 16-bits ID */
- Request->Data.GetTempFile.UniqueID = (++CsrGetTempFileUnique & 0xFFFF);
+ ApiMessage->Data.GetTempFile.UniqueID = (++CsrGetTempFileUnique & 0xFFFF);
- DPRINT("Returning: %u\n", Request->Data.GetTempFile.UniqueID);
+ DPRINT("Returning: %u\n", ApiMessage->Data.GetTempFile.UniqueID);
return STATUS_SUCCESS;
}
PWSTR lpBuffer;
DPRINT("CsrDefineDosDevice entered, Flags:%d, DeviceName:%wZ, TargetName:%wZ\n",
- Request->Data.DefineDosDeviceRequest.dwFlags,
- &Request->Data.DefineDosDeviceRequest.DeviceName,
- &Request->Data.DefineDosDeviceRequest.TargetName);
+ ApiMessage->Data.DefineDosDeviceRequest.dwFlags,
+ &ApiMessage->Data.DefineDosDeviceRequest.DeviceName,
+ &ApiMessage->Data.DefineDosDeviceRequest.TargetName);
Matched = AddHistory = FALSE;
HistoryEntry = NULL;
AdminSid = SystemSid = WorldSid = NULL;
SecurityDescriptor = NULL;
ListHead = &DosDeviceHistory;
- dwFlags = Request->Data.DefineDosDeviceRequest.dwFlags;
+ dwFlags = ApiMessage->Data.DefineDosDeviceRequest.dwFlags;
/* Validate the flags */
if ( (dwFlags & 0xFFFFFFF0) ||
{
Status =
RtlUpcaseUnicodeString(&RequestDeviceName,
- &Request->Data.DefineDosDeviceRequest.DeviceName,
+ &ApiMessage->Data.DefineDosDeviceRequest.DeviceName,
TRUE);
if (! NT_SUCCESS(Status))
_SEH2_LEAVE;
RequestLinkTarget =
- &Request->Data.DefineDosDeviceRequest.TargetName;
+ &ApiMessage->Data.DefineDosDeviceRequest.TargetName;
lpBuffer = (PWSTR) RtlAllocateHeap(Win32CsrApiHeap,
HEAP_ZERO_MEMORY,
RequestDeviceName.MaximumLength + 5 * sizeof(WCHAR));
CSR_API(CsrGetHandle)
{
NTSTATUS Status = STATUS_SUCCESS;
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
- Request->Data.GetInputHandleRequest.Handle = INVALID_HANDLE_VALUE;
+ ApiMessage->Data.GetInputHandleRequest.Handle = INVALID_HANDLE_VALUE;
RtlEnterCriticalSection(&ProcessData->HandleTableLock);
if (ProcessData->Console)
{
- DWORD DesiredAccess = Request->Data.GetInputHandleRequest.Access;
- DWORD ShareMode = Request->Data.GetInputHandleRequest.ShareMode;
+ DWORD DesiredAccess = ApiMessage->Data.GetInputHandleRequest.Access;
+ DWORD ShareMode = ApiMessage->Data.GetInputHandleRequest.ShareMode;
PCSRSS_CONSOLE Console = ProcessData->Console;
Object_t *Object;
EnterCriticalSection(&Console->Lock);
- if (Request->Type == GET_OUTPUT_HANDLE)
+ if (ApiMessage->ApiNumber == GET_OUTPUT_HANDLE)
Object = &Console->ActiveBuffer->Header;
else
Object = &Console->Header;
else
{
Status = Win32CsrInsertObject(ProcessData,
- &Request->Data.GetInputHandleRequest.Handle,
+ &ApiMessage->Data.GetInputHandleRequest.Handle,
Object,
DesiredAccess,
- Request->Data.GetInputHandleRequest.Inheritable,
+ ApiMessage->Data.GetInputHandleRequest.Inheritable,
ShareMode);
}
LeaveCriticalSection(&Console->Lock);
CSR_API(CsrCloseHandle)
{
- return Win32CsrReleaseObject(ProcessData, Request->Data.CloseHandleRequest.Handle);
+ return Win32CsrReleaseObject(CsrGetClientThread()->Process, ApiMessage->Data.CloseHandleRequest.Handle);
}
CSR_API(CsrVerifyHandle)
{
ULONG_PTR Index;
NTSTATUS Status = STATUS_SUCCESS;
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
- Index = (ULONG_PTR)Request->Data.VerifyHandleRequest.Handle >> 2;
+ Index = (ULONG_PTR)ApiMessage->Data.VerifyHandleRequest.Handle >> 2;
RtlEnterCriticalSection(&ProcessData->HandleTableLock);
if (Index >= ProcessData->HandleTableSize ||
ProcessData->HandleTable[Index].Object == NULL)
ULONG_PTR Index;
PCSRSS_HANDLE Entry;
DWORD DesiredAccess;
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
- Index = (ULONG_PTR)Request->Data.DuplicateHandleRequest.Handle >> 2;
+ Index = (ULONG_PTR)ApiMessage->Data.DuplicateHandleRequest.Handle >> 2;
RtlEnterCriticalSection(&ProcessData->HandleTableLock);
if (Index >= ProcessData->HandleTableSize
|| (Entry = &ProcessData->HandleTable[Index])->Object == NULL)
{
- DPRINT1("Couldn't dup invalid handle %p\n", Request->Data.DuplicateHandleRequest.Handle);
+ DPRINT1("Couldn't dup invalid handle %p\n", ApiMessage->Data.DuplicateHandleRequest.Handle);
RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
return STATUS_INVALID_HANDLE;
}
- if (Request->Data.DuplicateHandleRequest.Options & DUPLICATE_SAME_ACCESS)
+ if (ApiMessage->Data.DuplicateHandleRequest.Options & DUPLICATE_SAME_ACCESS)
{
DesiredAccess = Entry->Access;
}
else
{
- DesiredAccess = Request->Data.DuplicateHandleRequest.Access;
+ DesiredAccess = ApiMessage->Data.DuplicateHandleRequest.Access;
/* Make sure the source handle has all the desired flags */
if (~Entry->Access & DesiredAccess)
{
DPRINT1("Handle %p only has access %X; requested %X\n",
- Request->Data.DuplicateHandleRequest.Handle, Entry->Access, DesiredAccess);
+ ApiMessage->Data.DuplicateHandleRequest.Handle, Entry->Access, DesiredAccess);
RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
return STATUS_INVALID_PARAMETER;
}
}
- Request->Status = Win32CsrInsertObject(ProcessData,
- &Request->Data.DuplicateHandleRequest.Handle,
+ ApiMessage->Status = Win32CsrInsertObject(ProcessData,
+ &ApiMessage->Data.DuplicateHandleRequest.Handle,
Entry->Object,
DesiredAccess,
- Request->Data.DuplicateHandleRequest.Inheritable,
+ ApiMessage->Data.DuplicateHandleRequest.Inheritable,
Entry->ShareMode);
- if (NT_SUCCESS(Request->Status)
- && Request->Data.DuplicateHandleRequest.Options & DUPLICATE_CLOSE_SOURCE)
+ if (NT_SUCCESS(ApiMessage->Status)
+ && ApiMessage->Data.DuplicateHandleRequest.Options & DUPLICATE_CLOSE_SOURCE)
{
Win32CsrCloseHandleEntry(Entry);
}
RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
- return Request->Status;
+ return ApiMessage->Status;
}
CSR_API(CsrGetInputWaitHandle)
{
- Request->Data.GetConsoleInputWaitHandle.InputWaitHandle = ProcessData->ConsoleEvent;
+ ApiMessage->Data.GetConsoleInputWaitHandle.InputWaitHandle = CsrGetClientThread()->Process->ConsoleEvent;
return STATUS_SUCCESS;
}
CSR_API(CsrGetCommandHistoryLength)
{
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
NTSTATUS Status;
PHISTORY_BUFFER Hist;
INT i;
if (!Win32CsrValidateBuffer(ProcessData,
- Request->Data.GetCommandHistoryLength.ExeName.Buffer,
- Request->Data.GetCommandHistoryLength.ExeName.Length, 1))
+ ApiMessage->Data.GetCommandHistoryLength.ExeName.Buffer,
+ ApiMessage->Data.GetCommandHistoryLength.ExeName.Length, 1))
{
return STATUS_ACCESS_VIOLATION;
}
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (NT_SUCCESS(Status))
{
- Hist = HistoryFindBuffer(Console, &Request->Data.GetCommandHistory.ExeName);
+ Hist = HistoryFindBuffer(Console, &ApiMessage->Data.GetCommandHistory.ExeName);
if (Hist)
{
for (i = 0; i < Hist->NumEntries; i++)
Length += Hist->Entries[i].Length + sizeof(WCHAR);
}
- Request->Data.GetCommandHistoryLength.Length = Length;
+ ApiMessage->Data.GetCommandHistoryLength.Length = Length;
ConioUnlockConsole(Console);
}
return Status;
CSR_API(CsrGetCommandHistory)
{
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
NTSTATUS Status;
PHISTORY_BUFFER Hist;
- PBYTE Buffer = (PBYTE)Request->Data.GetCommandHistory.History;
- ULONG BufferSize = Request->Data.GetCommandHistory.Length;
+ PBYTE Buffer = (PBYTE)ApiMessage->Data.GetCommandHistory.History;
+ ULONG BufferSize = ApiMessage->Data.GetCommandHistory.Length;
INT i;
if (!Win32CsrValidateBuffer(ProcessData, Buffer, BufferSize, 1) ||
!Win32CsrValidateBuffer(ProcessData,
- Request->Data.GetCommandHistory.ExeName.Buffer,
- Request->Data.GetCommandHistory.ExeName.Length, 1))
+ ApiMessage->Data.GetCommandHistory.ExeName.Buffer,
+ ApiMessage->Data.GetCommandHistory.ExeName.Length, 1))
{
return STATUS_ACCESS_VIOLATION;
}
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (NT_SUCCESS(Status))
{
- Hist = HistoryFindBuffer(Console, &Request->Data.GetCommandHistory.ExeName);
+ Hist = HistoryFindBuffer(Console, &ApiMessage->Data.GetCommandHistory.ExeName);
if (Hist)
{
for (i = 0; i < Hist->NumEntries; i++)
Buffer += sizeof(WCHAR);
}
}
- Request->Data.GetCommandHistory.Length = Buffer - (PBYTE)Request->Data.GetCommandHistory.History;
+ ApiMessage->Data.GetCommandHistory.Length = Buffer - (PBYTE)ApiMessage->Data.GetCommandHistory.History;
ConioUnlockConsole(Console);
}
return Status;
CSR_API(CsrExpungeCommandHistory)
{
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
PHISTORY_BUFFER Hist;
NTSTATUS Status;
if (!Win32CsrValidateBuffer(ProcessData,
- Request->Data.ExpungeCommandHistory.ExeName.Buffer,
- Request->Data.ExpungeCommandHistory.ExeName.Length, 1))
+ ApiMessage->Data.ExpungeCommandHistory.ExeName.Buffer,
+ ApiMessage->Data.ExpungeCommandHistory.ExeName.Length, 1))
{
return STATUS_ACCESS_VIOLATION;
}
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (NT_SUCCESS(Status))
{
- Hist = HistoryFindBuffer(Console, &Request->Data.ExpungeCommandHistory.ExeName);
+ Hist = HistoryFindBuffer(Console, &ApiMessage->Data.ExpungeCommandHistory.ExeName);
HistoryDeleteBuffer(Hist);
ConioUnlockConsole(Console);
}
CSR_API(CsrSetHistoryNumberCommands)
{
+ PCSR_PROCESS ProcessData = CsrGetClientThread()->Process;
PCSRSS_CONSOLE Console;
PHISTORY_BUFFER Hist;
NTSTATUS Status;
- WORD MaxEntries = Request->Data.SetHistoryNumberCommands.NumCommands;
+ WORD MaxEntries = ApiMessage->Data.SetHistoryNumberCommands.NumCommands;
PUNICODE_STRING OldEntryList, NewEntryList;
if (!Win32CsrValidateBuffer(ProcessData,
- Request->Data.SetHistoryNumberCommands.ExeName.Buffer,
- Request->Data.SetHistoryNumberCommands.ExeName.Length, 1))
+ ApiMessage->Data.SetHistoryNumberCommands.ExeName.Buffer,
+ ApiMessage->Data.SetHistoryNumberCommands.ExeName.Length, 1))
{
return STATUS_ACCESS_VIOLATION;
}
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (NT_SUCCESS(Status))
{
- Hist = HistoryFindBuffer(Console, &Request->Data.SetHistoryNumberCommands.ExeName);
+ Hist = HistoryFindBuffer(Console, &ApiMessage->Data.SetHistoryNumberCommands.ExeName);
if (Hist)
{
OldEntryList = Hist->Entries;
CSR_API(CsrGetHistoryInfo)
{
PCSRSS_CONSOLE Console;
- NTSTATUS Status = ConioConsoleFromProcessData(ProcessData, &Console);
+ NTSTATUS Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
if (NT_SUCCESS(Status))
{
- Request->Data.SetHistoryInfo.HistoryBufferSize = Console->HistoryBufferSize;
- Request->Data.SetHistoryInfo.NumberOfHistoryBuffers = Console->NumberOfHistoryBuffers;
- Request->Data.SetHistoryInfo.dwFlags = Console->HistoryNoDup;
+ ApiMessage->Data.SetHistoryInfo.HistoryBufferSize = Console->HistoryBufferSize;
+ ApiMessage->Data.SetHistoryInfo.NumberOfHistoryBuffers = Console->NumberOfHistoryBuffers;
+ ApiMessage->Data.SetHistoryInfo.dwFlags = Console->HistoryNoDup;
ConioUnlockConsole(Console);
}
return Status;
CSR_API(CsrSetHistoryInfo)
{
PCSRSS_CONSOLE Console;
- NTSTATUS Status = ConioConsoleFromProcessData(ProcessData, &Console);
+ NTSTATUS Status = ConioConsoleFromProcessData(CsrGetClientThread()->Process, &Console);
if (NT_SUCCESS(Status))
{
- Console->HistoryBufferSize = (WORD)Request->Data.SetHistoryInfo.HistoryBufferSize;
- Console->NumberOfHistoryBuffers = (WORD)Request->Data.SetHistoryInfo.NumberOfHistoryBuffers;
- Console->HistoryNoDup = Request->Data.SetHistoryInfo.dwFlags & HISTORY_NO_DUP_FLAG;
+ Console->HistoryBufferSize = (WORD)ApiMessage->Data.SetHistoryInfo.HistoryBufferSize;
+ Console->NumberOfHistoryBuffers = (WORD)ApiMessage->Data.SetHistoryInfo.NumberOfHistoryBuffers;
+ Console->HistoryNoDup = ApiMessage->Data.SetHistoryInfo.dwFlags & HISTORY_NO_DUP_FLAG;
ConioUnlockConsole(Console);
}
return Status;
projects / reactos.git / commitdiff