* PROJECT: ReactOS system libraries
* FILE: lib/kernel32/misc/console.c
* PURPOSE: Win32 server console functions
- * PROGRAMMER: James Tabor
+ * PROGRAMMER: James Tabor
* <jimtabor@adsl-64-217-116-74.dsl.hstntx.swbell.net>
* UPDATE HISTORY:
* 199901?? ?? Created
extern BOOL WINAPI DefaultConsoleCtrlHandler(DWORD Event);
extern __declspec(noreturn) VOID CALLBACK ConsoleControlDispatcher(DWORD CodeAndFlag);
-extern CRITICAL_SECTION ConsoleLock;
+extern RTL_CRITICAL_SECTION ConsoleLock;
extern BOOL WINAPI IsDebuggerPresent(VOID);
case CTRL_C_EVENT:
DPRINT("Ctrl-C Event\n");
break;
-
+
case CTRL_BREAK_EVENT:
DPRINT("Ctrl-Break Event\n");
break;
DPRINT("Ctrl Close Event\n");
break;
- case CTRL_LOGOFF_EVENT:
+ case CTRL_LOGOFF_EVENT:
DPRINT("Ctrl Logoff Event\n");
break;
}
if(IsDebuggerPresent())
{
EXCEPTION_RECORD erException;
- erException.ExceptionCode =
+ erException.ExceptionCode =
(nCode == CTRL_C_EVENT ? DBG_CONTROL_C : DBG_CONTROL_BREAK);
erException.ExceptionFlags = 0;
erException.ExceptionRecord = NULL;
erException.ExceptionAddress = &DefaultConsoleCtrlHandler;
erException.NumberParameters = 0;
RtlRaiseException(&erException);
- }
+ }
RtlEnterCriticalSection(&ConsoleLock);
if(!(nCode == CTRL_C_EVENT &&
- NtCurrentPeb()->ProcessParameters->ProcessGroup & 1))
+ NtCurrentPeb()->ProcessParameters->ConsoleFlags & 1))
{
for(i = NrCtrlHandlers; i > 0; -- i)
if(CtrlHandlers[i - 1](nCode)) break;
RtlEnterCriticalSection(&ConsoleLock);
if(!(nCode == CTRL_C_EVENT &&
- NtCurrentPeb()->ProcessParameters->ProcessGroup & 1))
+ NtCurrentPeb()->ProcessParameters->ConsoleFlags & 1))
{
i = NrCtrlHandlers;
while(i > 0)
{
- if (i == 1 && (CodeAndFlag & MINLONG) &&
+ if (i == 1 && (CodeAndFlag & MINLONG) &&
(nCode == CTRL_LOGOFF_EVENT || nCode == CTRL_SHUTDOWN_EVENT))
break;
BOOL bInheritHandle,
DWORD dwOptions)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request;
+ ULONG CsrRequest;
NTSTATUS Status;
if (IsConsoleHandle (hConsole) == FALSE)
SetLastError (ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
-
- Request.Type = CSRSS_DUPLICATE_HANDLE;
+
+ CsrRequest = MAKE_CSR_API(DUPLICATE_HANDLE, CSR_NATIVE);
Request.Data.DuplicateHandleRequest.Handle = hConsole;
- Request.Data.DuplicateHandleRequest.ProcessId = GetCurrentProcessId();
+ Request.Data.DuplicateHandleRequest.ProcessId = GetTeb()->Cid.UniqueProcess;
Status = CsrClientCallServer(&Request,
- &Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status=Reply.Status))
+ NULL,
+ CsrRequest,
+ sizeof(CSR_API_MESSAGE));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status=Request.Status))
{
SetLastErrorByStatus(Status);
return INVALID_HANDLE_VALUE;
}
- return Reply.Data.DuplicateHandleReply.Handle;
+ return Request.Data.DuplicateHandleRequest.Handle;
}
* @unimplemented
*/
DWORD STDCALL
-GetConsoleAliasW (DWORD Unknown0,
- DWORD Unknown1,
- DWORD Unknown2,
- DWORD Unknown3)
+GetConsoleAliasW (LPWSTR lpSource,
+ LPWSTR lpTargetBuffer,
+ DWORD TargetBufferLength,
+ LPWSTR lpExeName)
/*
* Undocumented
*/
{
- DPRINT1("GetConsoleAliasW(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2, Unknown3);
+ DPRINT1("GetConsoleAliasW(0x%p, 0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", lpSource, lpTargetBuffer, TargetBufferLength, lpExeName);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
* @unimplemented
*/
DWORD STDCALL
-GetConsoleAliasA (DWORD Unknown0,
- DWORD Unknown1,
- DWORD Unknown2,
- DWORD Unknown3)
+GetConsoleAliasA (LPSTR lpSource,
+ LPSTR lpTargetBuffer,
+ DWORD TargetBufferLength,
+ LPSTR lpExeName)
/*
* Undocumented
*/
{
- DPRINT1("GetConsoleAliasA(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2, Unknown3);
+ DPRINT1("GetConsoleAliasA(0x%p, 0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", lpSource, lpTargetBuffer, TargetBufferLength, lpExeName);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
* @unimplemented
*/
DWORD STDCALL
-GetConsoleAliasExesW (DWORD Unknown0,
- DWORD Unknown1)
+GetConsoleAliasExesW (LPWSTR lpExeNameBuffer,
+ DWORD ExeNameBufferLength)
/*
* Undocumented
*/
{
- DPRINT1("GetConsoleAliasExesW(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1);
+ DPRINT1("GetConsoleAliasExesW(0x%p, 0x%x) UNIMPLEMENTED!\n", lpExeNameBuffer, ExeNameBufferLength);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
* @unimplemented
*/
DWORD STDCALL
-GetConsoleAliasExesA (DWORD Unknown0,
- DWORD Unknown1)
+GetConsoleAliasExesA (LPSTR lpExeNameBuffer,
+ DWORD ExeNameBufferLength)
/*
* Undocumented
*/
{
- DPRINT1("GetConsoleAliasExesA(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1);
+ DPRINT1("GetConsoleAliasExesA(0x%p, 0x%x) UNIMPLEMENTED!\n", lpExeNameBuffer, ExeNameBufferLength);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
-
+
/*
* @unimplemented
* @unimplemented
*/
DWORD STDCALL
-GetConsoleAliasesLengthW (DWORD Unknown0)
+GetConsoleAliasesLengthW (LPWSTR lpExeName)
/*
* Undocumented
*/
{
- DPRINT1("GetConsoleAliasesLengthW(0x%x) UNIMPLEMENTED!\n", Unknown0);
+ DPRINT1("GetConsoleAliasesLengthW(0x%p) UNIMPLEMENTED!\n", lpExeName);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
* @unimplemented
*/
DWORD STDCALL
-GetConsoleAliasesLengthA (DWORD Unknown0)
+GetConsoleAliasesLengthA (LPSTR lpExeName)
/*
* Undocumented
*/
{
- DPRINT1("GetConsoleAliasesLengthA(0x%x) UNIMPLEMENTED!\n", Unknown0);
+ DPRINT1("GetConsoleAliasesLengthA(0x%p) UNIMPLEMENTED!\n", lpExeName);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/*
* @unimplemented
*/
-DWORD STDCALL
+COORD STDCALL
GetConsoleFontSize(HANDLE hConsoleOutput,
DWORD nFont)
{
+ COORD Empty = {0, 0};
DPRINT1("GetConsoleFontSize(0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput, nFont);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return 0;
+ return Empty ;
}
* Undocumented
*/
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_SETGET_CONSOLE_HW_STATE;
+ 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,
- & Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ NULL,
+ CsrRequest,
+ sizeof(CSR_API_MESSAGE));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus(Status);
return FALSE;
}
- *State = Reply.Data.ConsoleHardwareStateReply.State;
- return TRUE;
+ *State = Request.Data.ConsoleHardwareStateRequest.State;
+ return TRUE;
}
* Undocumented
*/
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_GET_INPUT_WAIT_HANDLE;
- Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ CsrRequest = MAKE_CSR_API(GET_INPUT_WAIT_HANDLE, CSR_CONSOLE);
+ Status = CsrClientCallServer(&Request, NULL, CsrRequest,
+ sizeof(CSR_API_MESSAGE));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus(Status);
return 0;
}
- return (DWORD) Reply.Data.GetConsoleInputWaitHandle.InputWaitHandle;
+ return (DWORD) Request.Data.GetConsoleInputWaitHandle.InputWaitHandle;
}
* Undocumented
*/
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
PHANDLE phConsole = NULL;
NTSTATUS Status = STATUS_SUCCESS;
-
+
if(0 == _wcsicmp(wsName, L"CONIN$"))
{
- Request.Type = CSRSS_GET_INPUT_HANDLE;
- phConsole = & Reply.Data.GetInputHandleReply.InputHandle;
+ CsrRequest = MAKE_CSR_API(GET_INPUT_HANDLE, CSR_NATIVE);
+ phConsole = & Request.Data.GetInputHandleRequest.InputHandle;
}
else if (0 == _wcsicmp(wsName, L"CONOUT$"))
{
- Request.Type = CSRSS_GET_OUTPUT_HANDLE;
- phConsole = & Reply.Data.GetOutputHandleReply.OutputHandle;
+ CsrRequest = MAKE_CSR_API(GET_OUTPUT_HANDLE, CSR_NATIVE);
+ phConsole = & Request.Data.GetOutputHandleRequest.OutputHandle;
}
else
{
return(INVALID_HANDLE_VALUE);
}
Status = CsrClientCallServer(& Request,
- & Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ NULL,
+ CsrRequest,
+ sizeof(CSR_API_MESSAGE));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus(Status);
return INVALID_HANDLE_VALUE;
* Undocumented
*/
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_SETGET_CONSOLE_HW_STATE;
+ 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,
- & Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ NULL,
+ CsrRequest,
+ sizeof(CSR_API_MESSAGE));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus(Status);
return FALSE;
}
- return TRUE;
+ return TRUE;
}
BOOL STDCALL
VerifyConsoleIoHandle(HANDLE Handle)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_VERIFY_HANDLE;
+ CsrRequest = MAKE_CSR_API(VERIFY_HANDLE, CSR_NATIVE);
Request.Data.VerifyHandleRequest.Handle = Handle;
Status = CsrClientCallServer(&Request,
- &Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
+ NULL,
+ CsrRequest,
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status))
{
SetLastErrorByStatus(Status);
return FALSE;
}
- return (BOOL)NT_SUCCESS(Reply.Status);
+ return (BOOL)NT_SUCCESS(Request.Status);
}
* Undocumented
*/
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
if (IsConsoleHandle (Handle) == FALSE)
return FALSE;
}
- Request.Type = CSRSS_CLOSE_HANDLE;
+ CsrRequest = MAKE_CSR_API(CLOSE_HANDLE, CSR_NATIVE);
Request.Data.CloseHandleRequest.Handle = Handle;
Status = CsrClientCallServer(&Request,
- &Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
+ NULL,
+ CsrRequest,
+ sizeof(CSR_API_MESSAGE));
if (!NT_SUCCESS(Status))
{
SetLastErrorByStatus(Status);
return TRUE;
}
-
-/*
- * internal function
- */
-BOOL STDCALL
-IsConsoleHandle(HANDLE Handle)
-{
- if ((((ULONG)Handle) & 0x10000003) == 0x3)
- {
- return(TRUE);
- }
- return(FALSE);
-}
-
-
/*
* @implemented
*/
switch (nStdHandle)
{
case STD_INPUT_HANDLE:
- return Ppb->hStdInput;
+ return Ppb->StandardInput;
case STD_OUTPUT_HANDLE:
- return Ppb->hStdOutput;
+ return Ppb->StandardOutput;
case STD_ERROR_HANDLE:
- return Ppb->hStdError;
+ return Ppb->StandardError;
}
SetLastError (ERROR_INVALID_PARAMETER);
switch (nStdHandle)
{
case STD_INPUT_HANDLE:
- Ppb->hStdInput = hHandle;
+ Ppb->StandardInput = hHandle;
return TRUE;
case STD_OUTPUT_HANDLE:
- Ppb->hStdOutput = hHandle;
+ Ppb->StandardOutput = hHandle;
return TRUE;
case STD_ERROR_HANDLE:
- Ppb->hStdError = hHandle;
+ Ppb->StandardError = hHandle;
return TRUE;
}
LPVOID lpReserved,
BOOL bUnicode)
{
- PCSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ PCSR_API_MESSAGE Request;
+ ULONG CsrRequest;
NTSTATUS Status;
USHORT nChars;
- ULONG MessageSize, BufferSize, SizeBytes, CharSize;
+ ULONG SizeBytes, CharSize;
DWORD Written = 0;
-
- CharSize = (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
- BufferSize = sizeof(CSRSS_API_REQUEST) + min(nNumberOfCharsToWrite * CharSize, CSRSS_MAX_WRITE_CONSOLE_REQUEST);
- Request = RtlAllocateHeap(GetProcessHeap(), 0, BufferSize);
- if(Request == NULL)
+ CharSize = (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
+ Request = RtlAllocateHeap(RtlGetProcessHeap(), 0,
+ max(sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE)
+ + min(nNumberOfCharsToWrite, CSRSS_MAX_WRITE_CONSOLE / CharSize) * CharSize));
+ if (Request == NULL)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
- Request->Type = CSRSS_WRITE_CONSOLE;
+ CsrRequest = MAKE_CSR_API(WRITE_CONSOLE, CSR_CONSOLE);
Request->Data.WriteConsoleRequest.ConsoleHandle = hConsoleOutput;
Request->Data.WriteConsoleRequest.Unicode = bUnicode;
while(nNumberOfCharsToWrite > 0)
{
- nChars = min(nNumberOfCharsToWrite, CSRSS_MAX_WRITE_CONSOLE_REQUEST / CharSize);
+ nChars = min(nNumberOfCharsToWrite, CSRSS_MAX_WRITE_CONSOLE / CharSize);
Request->Data.WriteConsoleRequest.NrCharactersToWrite = nChars;
SizeBytes = nChars * CharSize;
memcpy(Request->Data.WriteConsoleRequest.Buffer, lpBuffer, SizeBytes);
- MessageSize = CSRSS_REQUEST_HEADER_SIZE + sizeof(CSRSS_WRITE_CONSOLE_REQUEST) + SizeBytes;
Status = CsrClientCallServer(Request,
- &Reply,
- MessageSize,
- sizeof(CSRSS_API_REPLY));
+ NULL,
+ CsrRequest,
+ max(sizeof(CSR_API_MESSAGE), CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE) + SizeBytes));
- if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request->Status))
{
- RtlFreeHeap(GetProcessHeap(), 0, Request);
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
SetLastErrorByStatus(Status);
return FALSE;
}
nNumberOfCharsToWrite -= nChars;
lpBuffer = (PVOID)((ULONG_PTR)lpBuffer + (ULONG_PTR)SizeBytes);
- Written += Reply.Data.WriteConsoleReply.NrCharactersWritten;
+ Written += Request->Data.WriteConsoleRequest.NrCharactersWritten;
}
- RtlFreeHeap(GetProcessHeap(), 0, Request);
-
if(lpNumberOfCharsWritten != NULL)
{
*lpNumberOfCharsWritten = Written;
}
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
return TRUE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL STDCALL
WriteConsoleA(HANDLE hConsoleOutput,
CONST VOID *lpBuffer,
DWORD nNumberOfCharsToWrite,
LPVOID lpReserved,
BOOL bUnicode)
{
- CSRSS_API_REQUEST Request;
- PCSRSS_API_REPLY Reply;
+ PCSR_API_MESSAGE Request;
+ ULONG CsrRequest;
NTSTATUS Status;
- ULONG BufferSize, CharSize, CharsRead = 0;
-
+ ULONG CharSize, CharsRead = 0;
+
CharSize = (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
-
- BufferSize = sizeof(CSRSS_API_REQUEST) + min(nNumberOfCharsToRead * CharSize, CSRSS_MAX_READ_CONSOLE_REQUEST);
- Reply = RtlAllocateHeap(GetProcessHeap(), 0, BufferSize);
- if(Reply == NULL)
+ Request = RtlAllocateHeap(RtlGetProcessHeap(), 0,
+ max(sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE)
+ + min(nNumberOfCharsToRead, CSRSS_MAX_READ_CONSOLE / CharSize) * CharSize));
+ if (Request == NULL)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
-
- Reply->Status = STATUS_SUCCESS;
+
+ Request->Status = STATUS_SUCCESS;
do
{
- if(Reply->Status == STATUS_PENDING)
+ if(Request->Status == STATUS_PENDING)
{
- Status = NtWaitForSingleObject(Reply->Data.ReadConsoleReply.EventHandle, FALSE, 0);
+ Status = NtWaitForSingleObject(Request->Data.ReadConsoleRequest.EventHandle, FALSE, 0);
if(!NT_SUCCESS(Status))
{
DPRINT1("Wait for console input failed!\n");
break;
}
}
-
- Request.Type = CSRSS_READ_CONSOLE;
- Request.Data.ReadConsoleRequest.ConsoleHandle = hConsoleInput;
- Request.Data.ReadConsoleRequest.Unicode = bUnicode;
- Request.Data.ReadConsoleRequest.NrCharactersToRead = min(nNumberOfCharsToRead, CSRSS_MAX_READ_CONSOLE_REQUEST / CharSize);
- Request.Data.ReadConsoleRequest.nCharsCanBeDeleted = CharsRead;
- Status = CsrClientCallServer(&Request,
- Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY) + (Request.Data.ReadConsoleRequest.NrCharactersToRead * CharSize));
-
- if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply->Status))
+
+ CsrRequest = MAKE_CSR_API(READ_CONSOLE, CSR_CONSOLE);
+ Request->Data.ReadConsoleRequest.ConsoleHandle = hConsoleInput;
+ Request->Data.ReadConsoleRequest.Unicode = bUnicode;
+ Request->Data.ReadConsoleRequest.NrCharactersToRead = min(nNumberOfCharsToRead, CSRSS_MAX_READ_CONSOLE / CharSize);
+ Request->Data.ReadConsoleRequest.nCharsCanBeDeleted = CharsRead;
+ Status = CsrClientCallServer(Request,
+ NULL,
+ CsrRequest,
+ max(sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE)
+ + Request->Data.ReadConsoleRequest.NrCharactersToRead * CharSize));
+
+ if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request->Status))
{
DPRINT1("CSR returned error in ReadConsole\n");
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
SetLastErrorByStatus(Status);
- RtlFreeHeap(GetProcessHeap(), 0, Reply);
return FALSE;
}
-
- nNumberOfCharsToRead -= Reply->Data.ReadConsoleReply.NrCharactersRead;
+
+ nNumberOfCharsToRead -= Request->Data.ReadConsoleRequest.NrCharactersRead;
memcpy((PVOID)((ULONG_PTR)lpBuffer + (ULONG_PTR)(CharsRead * CharSize)),
- Reply->Data.ReadConsoleReply.Buffer,
- Reply->Data.ReadConsoleReply.NrCharactersRead * CharSize);
- CharsRead += Reply->Data.ReadConsoleReply.NrCharactersRead;
-
- if(Reply->Status == STATUS_NOTIFY_CLEANUP)
+ Request->Data.ReadConsoleRequest.Buffer,
+ Request->Data.ReadConsoleRequest.NrCharactersRead * CharSize);
+ CharsRead += Request->Data.ReadConsoleRequest.NrCharactersRead;
+
+ if(Request->Status == STATUS_NOTIFY_CLEANUP)
{
if(CharsRead > 0)
{
CharsRead--;
nNumberOfCharsToRead++;
}
- Reply->Status = STATUS_PENDING;
+ Request->Status = STATUS_PENDING;
}
- } while(Reply->Status == STATUS_PENDING && nNumberOfCharsToRead > 0);
-
+ } while(Request->Status == STATUS_PENDING && nNumberOfCharsToRead > 0);
+
if(lpNumberOfCharsRead != NULL)
{
*lpNumberOfCharsRead = CharsRead;
}
-
+
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
+
return TRUE;
}
*/
BOOL STDCALL AllocConsole(VOID)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
HANDLE hStdError;
- if(NtCurrentPeb()->ProcessParameters->hConsole)
+ if(NtCurrentPeb()->ProcessParameters->ConsoleHandle)
{
DPRINT("AllocConsole: Allocate duplicate console to the same Process\n");
- SetLastErrorByStatus (STATUS_OBJECT_NAME_EXISTS);
- return FALSE;
+ SetLastErrorByStatus (STATUS_OBJECT_NAME_EXISTS);
+ return FALSE;
}
- Request.Data.AllocConsoleRequest.CtrlDispatcher = (PCONTROLDISPATCHER) &ConsoleControlDispatcher;
+ Request.Data.AllocConsoleRequest.CtrlDispatcher = ConsoleControlDispatcher;
+ Request.Data.AllocConsoleRequest.ConsoleNeeded = TRUE;
- Request.Type = CSRSS_ALLOC_CONSOLE;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
- if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ CsrRequest = MAKE_CSR_API(ALLOC_CONSOLE, CSR_CONSOLE);
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
{
SetLastErrorByStatus ( Status );
return FALSE;
}
- NtCurrentPeb()->ProcessParameters->hConsole = Reply.Data.AllocConsoleReply.Console;
- SetStdHandle( STD_INPUT_HANDLE, Reply.Data.AllocConsoleReply.InputHandle );
- SetStdHandle( STD_OUTPUT_HANDLE, Reply.Data.AllocConsoleReply.OutputHandle );
- hStdError = DuplicateConsoleHandle(Reply.Data.AllocConsoleReply.OutputHandle,
+ NtCurrentPeb()->ProcessParameters->ConsoleHandle = Request.Data.AllocConsoleRequest.Console;
+ SetStdHandle( STD_INPUT_HANDLE, Request.Data.AllocConsoleRequest.InputHandle );
+ SetStdHandle( STD_OUTPUT_HANDLE, Request.Data.AllocConsoleRequest.OutputHandle );
+ hStdError = DuplicateConsoleHandle(Request.Data.AllocConsoleRequest.OutputHandle,
0,
TRUE,
DUPLICATE_SAME_ACCESS);
// AG: I'm not sure if this is correct (what happens to std handles?)
// but I just tried to reverse what AllocConsole() does...
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_FREE_CONSOLE;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
- if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ CsrRequest = MAKE_CSR_API(FREE_CONSOLE, CSR_CONSOLE);
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
{
SetLastErrorByStatus ( Status );
return FALSE;
PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_SCREEN_BUFFER_INFO;
+ CsrRequest = MAKE_CSR_API(SCREEN_BUFFER_INFO, CSR_CONSOLE);
Request.Data.ScreenBufferInfoRequest.ConsoleHandle = hConsoleOutput;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
- if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
{
SetLastErrorByStatus ( Status );
return FALSE;
}
- *lpConsoleScreenBufferInfo = Reply.Data.ScreenBufferInfoReply.Info;
+ *lpConsoleScreenBufferInfo = Request.Data.ScreenBufferInfoRequest.Info;
return TRUE;
}
COORD dwCursorPosition
)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_SET_CURSOR;
+ CsrRequest = MAKE_CSR_API(SET_CURSOR, CSR_CONSOLE);
Request.Data.SetCursorRequest.ConsoleHandle = hConsoleOutput;
Request.Data.SetCursorRequest.Position = dwCursorPosition;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
- if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
{
SetLastErrorByStatus ( Status );
return FALSE;
LPDWORD lpNumberOfCharsWritten,
BOOL bUnicode)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_FILL_OUTPUT;
+ CsrRequest = MAKE_CSR_API(FILL_OUTPUT, CSR_CONSOLE);
Request.Data.FillOutputRequest.ConsoleHandle = hConsoleOutput;
Request.Data.FillOutputRequest.Unicode = bUnicode;
if(bUnicode)
Request.Data.FillOutputRequest.Char.AsciiChar = *((CHAR*)cCharacter);
Request.Data.FillOutputRequest.Position = dwWriteCoord;
Request.Data.FillOutputRequest.Length = nLength;
- Status = CsrClientCallServer(&Request, &Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
+ Status = CsrClientCallServer(&Request, NULL,
+ CsrRequest,
+ sizeof(CSR_API_MESSAGE));
- if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus(Status);
return FALSE;
if(lpNumberOfCharsWritten != NULL)
{
- *lpNumberOfCharsWritten = Reply.Data.FillOutputReply.NrCharactersWritten;
+ *lpNumberOfCharsWritten = Request.Data.FillOutputRequest.NrCharactersWritten;
}
-
+
return TRUE;
}
LPDWORD lpNumberOfEventsRead,
BOOL bUnicode)
{
- PCSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
NTSTATUS Status;
PVOID BufferBase;
PVOID BufferTargetBase;
ULONG Size;
-
+
if(lpBuffer == NULL)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
-
+
Size = nLength * sizeof(INPUT_RECORD);
- Status = CsrCaptureParameterBuffer((PVOID)lpBuffer, Size, &BufferBase, &BufferTargetBase);
+ Status = CsrCaptureParameterBuffer(NULL, Size, &BufferBase, &BufferTargetBase);
if(!NT_SUCCESS(Status))
{
SetLastErrorByStatus(Status);
return FALSE;
}
-
- Request = RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CSRSS_API_REQUEST));
- if(Request == NULL)
- {
- CsrReleaseParameterBuffer(BufferBase);
- SetLastError(ERROR_NOT_ENOUGH_MEMORY);
- return FALSE;
- }
-
- Request->Type = CSRSS_PEEK_CONSOLE_INPUT;
- Request->Data.PeekConsoleInputRequest.ConsoleHandle = hConsoleInput;
- Request->Data.PeekConsoleInputRequest.Unicode = bUnicode;
- Request->Data.PeekConsoleInputRequest.Length = nLength;
- Request->Data.PeekConsoleInputRequest.InputRecord = (INPUT_RECORD*)BufferTargetBase;
-
- Status = CsrClientCallServer(Request, &Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
-
- if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+
+ CsrRequest = MAKE_CSR_API(PEEK_CONSOLE_INPUT, CSR_CONSOLE);
+ Request.Data.PeekConsoleInputRequest.ConsoleHandle = hConsoleInput;
+ Request.Data.PeekConsoleInputRequest.Unicode = bUnicode;
+ Request.Data.PeekConsoleInputRequest.Length = nLength;
+ Request.Data.PeekConsoleInputRequest.InputRecord = (INPUT_RECORD*)BufferTargetBase;
+
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CsrRequest,
+ sizeof(CSR_API_MESSAGE));
+
+ if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
- RtlFreeHeap(GetProcessHeap(), 0, Request);
CsrReleaseParameterBuffer(BufferBase);
return FALSE;
}
- memcpy(lpBuffer, BufferBase, sizeof(INPUT_RECORD) * Reply.Data.PeekConsoleInputReply.Length);
+ memcpy(lpBuffer, BufferBase, sizeof(INPUT_RECORD) * Request.Data.PeekConsoleInputRequest.Length);
- RtlFreeHeap(GetProcessHeap(), 0, Request);
CsrReleaseParameterBuffer(BufferBase);
-
+
if(lpNumberOfEventsRead != NULL)
{
- *lpNumberOfEventsRead = Reply.Data.PeekConsoleInputReply.Length;
+ *lpNumberOfEventsRead = Request.Data.PeekConsoleInputRequest.Length;
}
-
+
return TRUE;
}
PINPUT_RECORD lpBuffer,
DWORD nLength,
LPDWORD lpNumberOfEventsRead
- )
+ )
{
return IntPeekConsoleInput(hConsoleInput, lpBuffer, nLength,
lpNumberOfEventsRead, TRUE);
LPDWORD lpNumberOfEventsRead,
BOOL bUnicode)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
ULONG Read;
NTSTATUS Status;
-
- Request.Type = CSRSS_READ_INPUT;
+
+ CsrRequest = MAKE_CSR_API(READ_INPUT, CSR_CONSOLE);
Request.Data.ReadInputRequest.ConsoleHandle = hConsoleInput;
Request.Data.ReadInputRequest.Unicode = bUnicode;
Read = 0;
while(nLength > 0)
{
- Status = CsrClientCallServer(&Request, &Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
- if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ Status = CsrClientCallServer(&Request, NULL,
+ CsrRequest,
+ sizeof(CSR_API_MESSAGE));
+ if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
if(Read == 0)
{
{
if(Read == 0)
{
- Status = NtWaitForSingleObject(Reply.Data.ReadInputReply.Event, FALSE, 0);
+ Status = NtWaitForSingleObject(Request.Data.ReadInputRequest.Event, FALSE, 0);
if(!NT_SUCCESS(Status))
{
SetLastErrorByStatus(Status);
}
else
{
- lpBuffer[Read++] = Reply.Data.ReadInputReply.Input;
+ lpBuffer[Read++] = Request.Data.ReadInputRequest.Input;
nLength--;
- if(!Reply.Data.ReadInputReply.MoreEvents)
+ if(!Request.Data.ReadInputRequest.MoreEvents)
{
/* nothing more to read, bail */
break;
}
}
}
-
+
if(lpNumberOfEventsRead != NULL)
{
*lpNumberOfEventsRead = Read;
}
-
+
return (Read > 0);
}
LPDWORD lpNumberOfEventsWritten,
BOOL bUnicode)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
PVOID BufferBase, BufferTargetBase;
NTSTATUS Status;
DWORD Size;
return FALSE;
}
- Request.Type = CSRSS_WRITE_CONSOLE_INPUT;
+ CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_INPUT, CSR_CONSOLE);
Request.Data.WriteConsoleInputRequest.ConsoleHandle = hConsoleInput;
Request.Data.WriteConsoleInputRequest.Unicode = bUnicode;
Request.Data.WriteConsoleInputRequest.Length = nLength;
Request.Data.WriteConsoleInputRequest.InputRecord = (PINPUT_RECORD)BufferTargetBase;
- Status = CsrClientCallServer(&Request, &Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
+ Status = CsrClientCallServer(&Request, NULL,
+ CsrRequest,
+ sizeof(CSR_API_MESSAGE));
CsrReleaseParameterBuffer(BufferBase);
-
- if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+
+ if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus(Status);
return FALSE;
}
-
+
if(lpNumberOfEventsWritten != NULL)
{
- *lpNumberOfEventsWritten = Reply.Data.WriteConsoleInputReply.Length;
+ *lpNumberOfEventsWritten = Request.Data.WriteConsoleInputRequest.Length;
}
return TRUE;
PSMALL_RECT lpReadRegion,
BOOL bUnicode)
{
- PCSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
PVOID BufferBase;
PVOID BufferTargetBase;
NTSTATUS Status;
DWORD Size, SizeX, SizeY;
-
+
if(lpBuffer == NULL)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
-
+
Size = dwBufferSize.X * dwBufferSize.Y * sizeof(CHAR_INFO);
- Status = CsrCaptureParameterBuffer((PVOID)lpBuffer, Size, &BufferBase, &BufferTargetBase);
+ Status = CsrCaptureParameterBuffer(NULL, Size, &BufferBase, &BufferTargetBase);
if(!NT_SUCCESS(Status))
{
SetLastErrorByStatus(Status);
return FALSE;
}
-
- Request = RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CSRSS_API_REQUEST));
- if(Request == NULL)
- {
- SetLastError(ERROR_NOT_ENOUGH_MEMORY);
- CsrReleaseParameterBuffer(BufferBase);
- return FALSE;
- }
-
- Request->Type = CSRSS_READ_CONSOLE_OUTPUT;
- Request->Data.ReadConsoleOutputRequest.ConsoleHandle = hConsoleOutput;
- Request->Data.ReadConsoleOutputRequest.Unicode = bUnicode;
- Request->Data.ReadConsoleOutputRequest.BufferSize = dwBufferSize;
- Request->Data.ReadConsoleOutputRequest.BufferCoord = dwBufferCoord;
- Request->Data.ReadConsoleOutputRequest.ReadRegion = *lpReadRegion;
- Request->Data.ReadConsoleOutputRequest.CharInfo = (PCHAR_INFO)BufferTargetBase;
-
- Status = CsrClientCallServer(Request, &Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
- if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ CsrRequest = MAKE_CSR_API(READ_CONSOLE_OUTPUT, CSR_CONSOLE);
+ Request.Data.ReadConsoleOutputRequest.ConsoleHandle = hConsoleOutput;
+ Request.Data.ReadConsoleOutputRequest.Unicode = bUnicode;
+ Request.Data.ReadConsoleOutputRequest.BufferSize = dwBufferSize;
+ Request.Data.ReadConsoleOutputRequest.BufferCoord = dwBufferCoord;
+ Request.Data.ReadConsoleOutputRequest.ReadRegion = *lpReadRegion;
+ Request.Data.ReadConsoleOutputRequest.CharInfo = (PCHAR_INFO)BufferTargetBase;
+
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CsrRequest,
+ sizeof(CSR_API_MESSAGE));
+
+ if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus(Status);
- RtlFreeHeap(GetProcessHeap(), 0, Request);
CsrReleaseParameterBuffer(BufferBase);
return FALSE;
}
-
- SizeX = Reply.Data.ReadConsoleOutputReply.ReadRegion.Right - Reply.Data.ReadConsoleOutputReply.ReadRegion.Left + 1;
- SizeY = Reply.Data.ReadConsoleOutputReply.ReadRegion.Bottom - Reply.Data.ReadConsoleOutputReply.ReadRegion.Top + 1;
-
+
+ SizeX = Request.Data.ReadConsoleOutputRequest.ReadRegion.Right - Request.Data.ReadConsoleOutputRequest.ReadRegion.Left + 1;
+ SizeY = Request.Data.ReadConsoleOutputRequest.ReadRegion.Bottom - Request.Data.ReadConsoleOutputRequest.ReadRegion.Top + 1;
+
memcpy(lpBuffer, BufferBase, sizeof(CHAR_INFO) * SizeX * SizeY);
-
- RtlFreeHeap(GetProcessHeap(), 0, Request);
+
CsrReleaseParameterBuffer(BufferBase);
-
- *lpReadRegion = Reply.Data.ReadConsoleOutputReply.ReadRegion;
-
+
+ *lpReadRegion = Request.Data.ReadConsoleOutputRequest.ReadRegion;
+
return TRUE;
}
PSMALL_RECT lpWriteRegion,
BOOL bUnicode)
{
- PCSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
NTSTATUS Status;
ULONG Size;
PVOID BufferBase;
SetLastErrorByStatus(Status);
return(FALSE);
}
-
- Request = RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(CSRSS_API_REQUEST));
- if (Request == NULL)
- {
- CsrReleaseParameterBuffer(BufferBase);
- SetLastError(ERROR_NOT_ENOUGH_MEMORY);
- return FALSE;
- }
- Request->Type = CSRSS_WRITE_CONSOLE_OUTPUT;
- Request->Data.WriteConsoleOutputRequest.ConsoleHandle = hConsoleOutput;
- Request->Data.WriteConsoleOutputRequest.Unicode = bUnicode;
- Request->Data.WriteConsoleOutputRequest.BufferSize = dwBufferSize;
- Request->Data.WriteConsoleOutputRequest.BufferCoord = dwBufferCoord;
- Request->Data.WriteConsoleOutputRequest.WriteRegion = *lpWriteRegion;
- Request->Data.WriteConsoleOutputRequest.CharInfo =
+
+ CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_OUTPUT, CSR_CONSOLE);
+ Request.Data.WriteConsoleOutputRequest.ConsoleHandle = hConsoleOutput;
+ Request.Data.WriteConsoleOutputRequest.Unicode = bUnicode;
+ Request.Data.WriteConsoleOutputRequest.BufferSize = dwBufferSize;
+ Request.Data.WriteConsoleOutputRequest.BufferCoord = dwBufferCoord;
+ Request.Data.WriteConsoleOutputRequest.WriteRegion = *lpWriteRegion;
+ Request.Data.WriteConsoleOutputRequest.CharInfo =
(CHAR_INFO*)BufferTargetBase;
-
- Status = CsrClientCallServer(Request, &Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ Status = CsrClientCallServer(&Request,
+ NULL,
+ CsrRequest,
+ sizeof(CSR_API_MESSAGE));
+
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
CsrReleaseParameterBuffer(BufferBase);
- RtlFreeHeap(GetProcessHeap(), 0, Request);
SetLastErrorByStatus(Status);
return FALSE;
}
-
- RtlFreeHeap(GetProcessHeap(), 0, Request);
+
CsrReleaseParameterBuffer(BufferBase);
-
- *lpWriteRegion = Reply.Data.WriteConsoleOutputReply.WriteRegion;
-
+
+ *lpWriteRegion = Request.Data.WriteConsoleOutputRequest.WriteRegion;
+
return(TRUE);
}
LPDWORD lpNumberOfCharsRead,
BOOL bUnicode)
{
- CSRSS_API_REQUEST Request;
- PCSRSS_API_REPLY Reply;
+ PCSR_API_MESSAGE Request; ULONG CsrRequest;
NTSTATUS Status;
ULONG nChars, SizeBytes, CharSize;
DWORD CharsRead = 0;
-
+
CharSize = (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
-
- nChars = min(nLength, CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR / CharSize);
+
+ nChars = min(nLength, CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR) / CharSize;
SizeBytes = nChars * CharSize;
- Reply = RtlAllocateHeap(GetProcessHeap(), 0,
- sizeof(CSRSS_API_REPLY) + SizeBytes);
- if(Reply == NULL)
+ Request = RtlAllocateHeap(RtlGetProcessHeap(), 0,
+ max(sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_CHAR)
+ + min (nChars, CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR / CharSize) * CharSize));
+ if (Request == NULL)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
-
- Request.Type = CSRSS_READ_CONSOLE_OUTPUT_CHAR;
- Request.Data.ReadConsoleOutputCharRequest.ConsoleHandle = hConsoleOutput;
- Request.Data.ReadConsoleOutputCharRequest.Unicode = bUnicode;
- Request.Data.ReadConsoleOutputCharRequest.ReadCoord = dwReadCoord;
+ CsrRequest = MAKE_CSR_API(READ_CONSOLE_OUTPUT_CHAR, CSR_CONSOLE);
+ Request->Data.ReadConsoleOutputCharRequest.ConsoleHandle = hConsoleOutput;
+ Request->Data.ReadConsoleOutputCharRequest.Unicode = bUnicode;
+ Request->Data.ReadConsoleOutputCharRequest.ReadCoord = dwReadCoord;
while(nLength > 0)
{
DWORD BytesRead;
-
- Request.Data.ReadConsoleOutputCharRequest.NumCharsToRead = min(nLength, nChars);
-
- Status = CsrClientCallServer(&Request,
- Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY) + SizeBytes);
- if(!NT_SUCCESS(Status) || !NT_SUCCESS(Reply->Status))
+
+ Request->Data.ReadConsoleOutputCharRequest.NumCharsToRead = min(nLength, nChars);
+ SizeBytes = Request->Data.ReadConsoleOutputCharRequest.NumCharsToRead * CharSize;
+
+ Status = CsrClientCallServer(Request,
+ NULL,
+ CsrRequest,
+ max (sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_CHAR) + SizeBytes));
+ if(!NT_SUCCESS(Status) || !NT_SUCCESS(Request->Status))
{
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
SetLastErrorByStatus(Status);
break;
}
- BytesRead = Reply->Data.ReadConsoleOutputCharReply.CharsRead * CharSize;
- memcpy(lpCharacter, &Reply->Data.ReadConsoleOutputCharReply.String[0], BytesRead);
+ BytesRead = Request->Data.ReadConsoleOutputCharRequest.CharsRead * CharSize;
+ memcpy(lpCharacter, Request->Data.ReadConsoleOutputCharRequest.String, BytesRead);
lpCharacter = (PVOID)((ULONG_PTR)lpCharacter + (ULONG_PTR)BytesRead);
- CharsRead += Reply->Data.ReadConsoleOutputCharReply.CharsRead;
- nLength -= Reply->Data.ReadConsoleOutputCharReply.CharsRead;
-
- Request.Data.ReadConsoleOutputCharRequest.ReadCoord = Reply->Data.ReadConsoleOutputCharReply.EndCoord;
+ CharsRead += Request->Data.ReadConsoleOutputCharRequest.CharsRead;
+ nLength -= Request->Data.ReadConsoleOutputCharRequest.CharsRead;
+
+ Request->Data.ReadConsoleOutputCharRequest.ReadCoord = Request->Data.ReadConsoleOutputCharRequest.EndCoord;
}
- RtlFreeHeap(GetProcessHeap(), 0, Reply);
-
if(lpNumberOfCharsRead != NULL)
{
*lpNumberOfCharsRead = CharsRead;
}
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
+
return TRUE;
}
LPDWORD lpNumberOfAttrsRead
)
{
- CSRSS_API_REQUEST Request;
- PCSRSS_API_REPLY Reply;
+ PCSR_API_MESSAGE Request; ULONG CsrRequest;
NTSTATUS Status;
- DWORD Size, i;
-
- Reply = RtlAllocateHeap(GetProcessHeap(), 0,
- sizeof(CSRSS_API_REPLY) + min(nLength, CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB));
- if (Reply == NULL)
- {
- SetLastError(ERROR_OUTOFMEMORY);
- return(FALSE);
- }
+ DWORD Size;
if (lpNumberOfAttrsRead != NULL)
*lpNumberOfAttrsRead = nLength;
- Request.Type = CSRSS_READ_CONSOLE_OUTPUT_ATTRIB;
- Request.Data.ReadConsoleOutputAttribRequest.ConsoleHandle = hConsoleOutput;
- Request.Data.ReadConsoleOutputAttribRequest.ReadCoord = dwReadCoord;
+ Request = RtlAllocateHeap(RtlGetProcessHeap(), 0,
+ max(sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_ATTRIB)
+ + min (nLength, CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB / sizeof(WORD)) * sizeof(WORD)));
+ if (Request == NULL)
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ return FALSE;
+ }
+
+ CsrRequest = MAKE_CSR_API(READ_CONSOLE_OUTPUT_ATTRIB, CSR_CONSOLE);
+ Request->Data.ReadConsoleOutputAttribRequest.ConsoleHandle = hConsoleOutput;
+ Request->Data.ReadConsoleOutputAttribRequest.ReadCoord = dwReadCoord;
while (nLength != 0)
{
- if (nLength > CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB)
- Size = CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB;
+ if (nLength > CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB / sizeof(WORD))
+ Size = CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB / sizeof(WCHAR);
else
Size = nLength;
- Request.Data.ReadConsoleOutputAttribRequest.NumAttrsToRead = Size;
+ Request->Data.ReadConsoleOutputAttribRequest.NumAttrsToRead = Size;
- Status = CsrClientCallServer(&Request,
- Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY) + Size);
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Reply->Status))
+ Status = CsrClientCallServer(Request,
+ NULL,
+ CsrRequest,
+ max (sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_ATTRIB) + Size * sizeof(WORD)));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Request->Status))
{
- RtlFreeHeap(GetProcessHeap(), 0, Reply);
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
SetLastErrorByStatus(Status);
return(FALSE);
}
- // Convert CHARs to WORDs
- for(i = 0; i < Size; ++i)
- *lpAttribute++ = Reply->Data.ReadConsoleOutputAttribReply.String[i];
-
+ memcpy(lpAttribute, Request->Data.ReadConsoleOutputAttribRequest.Attribute, Size * sizeof(WORD));
+ lpAttribute += Size;
nLength -= Size;
- Request.Data.ReadConsoleOutputAttribRequest.ReadCoord = Reply->Data.ReadConsoleOutputAttribReply.EndCoord;
+ Request->Data.ReadConsoleOutputAttribRequest.ReadCoord = Request->Data.ReadConsoleOutputAttribRequest.EndCoord;
}
- RtlFreeHeap(GetProcessHeap(), 0, Reply);
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
return(TRUE);
}
LPDWORD lpNumberOfCharsWritten,
BOOL bUnicode)
{
- PCSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ PCSR_API_MESSAGE Request; ULONG CsrRequest;
NTSTATUS Status;
ULONG SizeBytes, CharSize, nChars;
DWORD Written = 0;
-
+
CharSize = (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
-
- nChars = min(nLength, CSRSS_MAX_WRITE_CONSOLE_REQUEST / CharSize);
+
+ nChars = min(nLength, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR / CharSize);
SizeBytes = nChars * CharSize;
- Request = RtlAllocateHeap(GetProcessHeap(), 0,
- sizeof(CSRSS_API_REQUEST) + (nChars * CharSize));
- if(Request == NULL)
+ Request = RtlAllocateHeap(RtlGetProcessHeap(), 0,
+ max (sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_CHAR)
+ + min (nChars, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR / CharSize) * CharSize));
+ if (Request == NULL)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
- Request->Type = CSRSS_WRITE_CONSOLE_OUTPUT_CHAR;
+ CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_OUTPUT_CHAR, CSR_CONSOLE);
Request->Data.WriteConsoleOutputCharRequest.ConsoleHandle = hConsoleOutput;
Request->Data.WriteConsoleOutputCharRequest.Unicode = bUnicode;
Request->Data.WriteConsoleOutputCharRequest.Coord = dwWriteCoord;
while(nLength > 0)
{
DWORD BytesWrite;
-
+
Request->Data.WriteConsoleOutputCharRequest.Length = min(nLength, nChars);
BytesWrite = Request->Data.WriteConsoleOutputCharRequest.Length * CharSize;
- memcpy(&Request->Data.WriteConsoleOutputCharRequest.String[0], lpCharacter, BytesWrite);
+ memcpy(Request->Data.WriteConsoleOutputCharRequest.String, lpCharacter, BytesWrite);
- Status = CsrClientCallServer(Request, &Reply,
- sizeof(CSRSS_API_REQUEST) + BytesWrite,
- sizeof(CSRSS_API_REPLY));
+ Status = CsrClientCallServer(Request,
+ NULL,
+ CsrRequest,
+ max (sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_CHAR) + BytesWrite));
- if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request->Status))
{
- RtlFreeHeap(GetProcessHeap(), 0, Request);
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
SetLastErrorByStatus(Status);
return FALSE;
}
- nLength -= Reply.Data.WriteConsoleOutputCharReply.NrCharactersWritten;
- lpCharacter = (PVOID)((ULONG_PTR)lpCharacter + (ULONG_PTR)(Reply.Data.WriteConsoleOutputCharReply.NrCharactersWritten * CharSize));
- Written += Reply.Data.WriteConsoleOutputCharReply.NrCharactersWritten;
+ nLength -= Request->Data.WriteConsoleOutputCharRequest.NrCharactersWritten;
+ lpCharacter = (PVOID)((ULONG_PTR)lpCharacter + (ULONG_PTR)(Request->Data.WriteConsoleOutputCharRequest.NrCharactersWritten * CharSize));
+ Written += Request->Data.WriteConsoleOutputCharRequest.NrCharactersWritten;
- Request->Data.WriteConsoleOutputCharRequest.Coord = Reply.Data.WriteConsoleOutputCharReply.EndCoord;
+ Request->Data.WriteConsoleOutputCharRequest.Coord = Request->Data.WriteConsoleOutputCharRequest.EndCoord;
}
- RtlFreeHeap(GetProcessHeap(), 0, Request);
-
if(lpNumberOfCharsWritten != NULL)
{
*lpNumberOfCharsWritten = Written;
}
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
+
return TRUE;
}
LPDWORD lpNumberOfAttrsWritten
)
{
- PCSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ PCSR_API_MESSAGE Request; ULONG CsrRequest;
NTSTATUS Status;
WORD Size;
- int c;
-
- Request = RtlAllocateHeap(GetProcessHeap(), 0,
- sizeof(CSRSS_API_REQUEST) +
- min(nLength, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB));
- if( !Request )
- {
- SetLastError( ERROR_OUTOFMEMORY );
- return FALSE;
- }
- Request->Type = CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB;
+
+ Request = RtlAllocateHeap(RtlGetProcessHeap(), 0,
+ max (sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB)
+ + min(nLength, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB / sizeof(WORD)) * sizeof(WORD)));
+ if (Request == NULL)
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ return FALSE;
+ }
+
+ CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_OUTPUT_ATTRIB, CSR_CONSOLE);
Request->Data.WriteConsoleOutputAttribRequest.ConsoleHandle = hConsoleOutput;
Request->Data.WriteConsoleOutputAttribRequest.Coord = dwWriteCoord;
if( lpNumberOfAttrsWritten )
*lpNumberOfAttrsWritten = nLength;
while( nLength )
{
- Size = nLength > CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB ? CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB : nLength;
+ Size = min(nLength, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB / sizeof(WORD));
Request->Data.WriteConsoleOutputAttribRequest.Length = Size;
- for( c = 0; c < Size; c++ )
- Request->Data.WriteConsoleOutputAttribRequest.String[c] = (char)lpAttribute[c];
- Status = CsrClientCallServer( Request, &Reply, sizeof( CSRSS_API_REQUEST ) + (Size * 2), sizeof( CSRSS_API_REPLY ) );
- if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ memcpy(Request->Data.WriteConsoleOutputAttribRequest.Attribute, lpAttribute, Size * sizeof(WORD));
+
+ Status = CsrClientCallServer( Request,
+ NULL,
+ CsrRequest,
+ max (sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB) + Size * sizeof(WORD)));
+
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request->Status ) )
{
- RtlFreeHeap( GetProcessHeap(), 0, Request );
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
SetLastErrorByStatus ( Status );
return FALSE;
}
nLength -= Size;
lpAttribute += Size;
- Request->Data.WriteConsoleOutputAttribRequest.Coord = Reply.Data.WriteConsoleOutputAttribReply.EndCoord;
+ Request->Data.WriteConsoleOutputAttribRequest.Coord = Request->Data.WriteConsoleOutputAttribRequest.EndCoord;
}
-
- RtlFreeHeap( GetProcessHeap(), 0, Request );
+
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
+
return TRUE;
}
LPDWORD lpNumberOfAttrsWritten
)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_FILL_OUTPUT_ATTRIB;
+ CsrRequest = MAKE_CSR_API(FILL_OUTPUT_ATTRIB, CSR_CONSOLE);
Request.Data.FillOutputAttribRequest.ConsoleHandle = hConsoleOutput;
Request.Data.FillOutputAttribRequest.Attribute = wAttribute;
Request.Data.FillOutputAttribRequest.Coord = dwWriteCoord;
Request.Data.FillOutputAttribRequest.Length = nLength;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
- if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
{
SetLastErrorByStatus ( Status );
return FALSE;
LPDWORD lpMode
)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
- NTSTATUS Status;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
- Request.Type = CSRSS_GET_CONSOLE_MODE;
+ NTSTATUS Status;
+
+ CsrRequest = MAKE_CSR_API(GET_CONSOLE_MODE, CSR_CONSOLE);
Request.Data.GetConsoleModeRequest.ConsoleHandle = hConsoleHandle;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
- if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
{
SetLastErrorByStatus ( Status );
return FALSE;
}
- *lpMode = Reply.Data.GetConsoleModeReply.ConsoleMode;
+ *lpMode = Request.Data.GetConsoleModeRequest.ConsoleMode;
return TRUE;
}
LPDWORD lpNumberOfEvents
)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
-
+
if(lpNumberOfEvents == NULL)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
-
- Request.Type = CSRSS_GET_NUM_INPUT_EVENTS;
+
+ CsrRequest = MAKE_CSR_API(GET_NUM_INPUT_EVENTS, CSR_CONSOLE);
Request.Data.GetNumInputEventsRequest.ConsoleHandle = hConsoleInput;
- Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST), sizeof(CSRSS_API_REPLY));
- if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
+ if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus(Status);
return FALSE;
}
-
- *lpNumberOfEvents = Reply.Data.GetNumInputEventsReply.NumInputEvents;
-
+
+ *lpNumberOfEvents = Request.Data.GetNumInputEventsRequest.NumInputEvents;
+
return TRUE;
}
PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_GET_CURSOR_INFO;
+ CsrRequest = MAKE_CSR_API(GET_CURSOR_INFO, CSR_CONSOLE);
Request.Data.GetCursorInfoRequest.ConsoleHandle = hConsoleOutput;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
- if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
{
SetLastErrorByStatus ( Status );
return FALSE;
}
- *lpConsoleCursorInfo = Reply.Data.GetCursorInfoReply.Info;
+ *lpConsoleCursorInfo = Request.Data.GetCursorInfoRequest.Info;
return TRUE;
}
DWORD dwMode
)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
- NTSTATUS Status;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
- Request.Type = CSRSS_SET_CONSOLE_MODE;
+ NTSTATUS Status;
+
+ if (!IsConsoleHandle (hConsoleHandle))
+ {
+ DPRINT("SetConsoleMode was called with a non console handle\n");
+ SetLastError (ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+
+
+ CsrRequest = MAKE_CSR_API(SET_CONSOLE_MODE, CSR_CONSOLE);
Request.Data.SetConsoleModeRequest.ConsoleHandle = hConsoleHandle;
Request.Data.SetConsoleModeRequest.Mode = dwMode;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
- if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
{
SetLastErrorByStatus ( Status );
return FALSE;
HANDLE hConsoleOutput
)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_SET_SCREEN_BUFFER;
+ CsrRequest = MAKE_CSR_API(SET_SCREEN_BUFFER, CSR_CONSOLE);
Request.Data.SetScreenBufferRequest.OutputHandle = hConsoleOutput;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
- if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
{
SetLastErrorByStatus ( Status );
return FALSE;
HANDLE hConsoleInput
)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_FLUSH_INPUT_BUFFER;
+ CsrRequest = MAKE_CSR_API(FLUSH_INPUT_BUFFER, CSR_CONSOLE);
Request.Data.FlushInputBufferRequest.ConsoleInput = hConsoleInput;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
- if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
{
SetLastErrorByStatus ( Status );
return FALSE;
CONST CONSOLE_CURSOR_INFO *lpConsoleCursorInfo
)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_SET_CURSOR_INFO;
+ CsrRequest = MAKE_CSR_API(SET_CURSOR_INFO, CSR_CONSOLE);
Request.Data.SetCursorInfoRequest.ConsoleHandle = hConsoleOutput;
Request.Data.SetCursorInfoRequest.Info = *lpConsoleCursorInfo;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
- if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
{
SetLastErrorByStatus ( Status );
return FALSE;
PCHAR_INFO lpFill,
BOOL bUnicode)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_SCROLL_CONSOLE_SCREEN_BUFFER;
+ 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;
Request.Data.ScrollConsoleScreenBufferRequest.DestinationOrigin = dwDestinationOrigin;
Request.Data.ScrollConsoleScreenBufferRequest.Fill = *lpFill;
- Status = CsrClientCallServer(&Request, &Reply,
- sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
+ Status = CsrClientCallServer(&Request, NULL,
+ CsrRequest,
+ sizeof(CSR_API_MESSAGE));
- if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus(Status);
return FALSE;
WORD wAttributes
)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_SET_ATTRIB;
+ CsrRequest = MAKE_CSR_API(SET_ATTRIB, CSR_CONSOLE);
Request.Data.SetAttribRequest.ConsoleHandle = hConsoleOutput;
Request.Data.SetAttribRequest.Attrib = wAttributes;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
- if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
{
SetLastErrorByStatus ( Status );
return FALSE;
if (CtrlHandlers == NULL)
{
CtrlHandlers = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY,
- NrCtrlHandlers * sizeof(PHANDLER_ROUTINE));
+ NrCtrlHandlers * sizeof(PHANDLER_ROUTINE));
}
else
{
CtrlHandlers = RtlReAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY,
(PVOID)CtrlHandlers,
- NrCtrlHandlers * sizeof(PHANDLER_ROUTINE));
+ NrCtrlHandlers * sizeof(PHANDLER_ROUTINE));
}
if (CtrlHandlers == NULL)
{
if ( ((void*)(CtrlHandlers[i])) == (void*)HandlerRoutine)
{
NrCtrlHandlers--;
- memmove(CtrlHandlers + i, CtrlHandlers + i + 1,
+ memmove(CtrlHandlers + i, CtrlHandlers + i + 1,
(NrCtrlHandlers - i) * sizeof(PHANDLER_ROUTINE));
- CtrlHandlers =
+ CtrlHandlers =
RtlReAllocateHeap(RtlGetProcessHeap(),
HEAP_ZERO_MEMORY,
(PVOID)CtrlHandlers,
DWORD nSize
)
{
- CSRSS_API_REQUEST Request;
- PCSRSS_API_REPLY Reply;
+ PCSR_API_MESSAGE Request; ULONG CsrRequest;
NTSTATUS Status;
HANDLE hConsole;
return 0;
}
- Reply = RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CSRSS_API_REPLY) + CSRSS_MAX_TITLE_LENGTH * sizeof(WCHAR));
- if(Reply == NULL)
+ Request = RtlAllocateHeap(RtlGetProcessHeap(), 0,
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_GET_TITLE) + CSRSS_MAX_TITLE_LENGTH * sizeof(WCHAR));
+ if (Request == NULL)
{
- CloseHandle(hConsole);
- SetLastError(ERROR_OUTOFMEMORY);
- return 0;
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ return FALSE;
}
- Request.Type = CSRSS_GET_TITLE;
- Request.Data.GetTitleRequest.ConsoleHandle = hConsole;
-
- Status = CsrClientCallServer(&Request, Reply, sizeof(CSRSS_API_REQUEST), sizeof(CSRSS_API_REPLY) + CSRSS_MAX_TITLE_LENGTH * sizeof(WCHAR));
+ CsrRequest = MAKE_CSR_API(GET_TITLE, CSR_CONSOLE);
+ Request->Data.GetTitleRequest.ConsoleHandle = hConsole;
+
+ Status = CsrClientCallServer(Request,
+ NULL,
+ CsrRequest,
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_GET_TITLE) + CSRSS_MAX_TITLE_LENGTH * sizeof(WCHAR));
CloseHandle(hConsole);
- if(!NT_SUCCESS(Status) || !(NT_SUCCESS(Status = Reply->Status)))
+ if(!NT_SUCCESS(Status) || !(NT_SUCCESS(Status = Request->Status)))
{
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
SetLastErrorByStatus(Status);
- RtlFreeHeap(GetProcessHeap(), 0, Reply);
return 0;
}
-
- if(nSize * sizeof(WCHAR) < Reply->Data.GetTitleReply.Length)
+
+ if(nSize * sizeof(WCHAR) < Request->Data.GetTitleRequest.Length)
{
- wcsncpy(lpConsoleTitle, Reply->Data.GetTitleReply.Title, nSize - 1);
+ wcsncpy(lpConsoleTitle, Request->Data.GetTitleRequest.Title, nSize - 1);
lpConsoleTitle[nSize--] = L'\0';
}
else
- {
- nSize = Reply->Data.GetTitleReply.Length / sizeof (WCHAR);
- wcscpy(lpConsoleTitle, Reply->Data.GetTitleReply.Title);
+ {
+ nSize = Request->Data.GetTitleRequest.Length / sizeof (WCHAR);
+ wcscpy(lpConsoleTitle, Request->Data.GetTitleRequest.Title);
lpConsoleTitle[nSize] = L'\0';
}
-
- RtlFreeHeap(GetProcessHeap(), 0, Reply);
+
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
+
return nSize;
}
wchar_t WideTitle [CSRSS_MAX_TITLE_LENGTH];
DWORD nWideTitle = sizeof WideTitle;
DWORD nWritten;
-
+
if (!lpConsoleTitle || !nSize) return 0;
nWideTitle = GetConsoleTitleW( (LPWSTR) WideTitle, nWideTitle );
if (!nWideTitle) return 0;
if ( (nWritten = WideCharToMultiByte(
- CP_ACP, // ANSI code page
- 0, // performance and mapping flags
- (LPWSTR) WideTitle, // address of wide-character string
- nWideTitle, // number of characters in string
- lpConsoleTitle, // address of buffer for new string
- nSize, // size of buffer
+ CP_ACP, // ANSI code page
+ 0, // performance and mapping flags
+ (LPWSTR) WideTitle, // address of wide-character string
+ nWideTitle, // number of characters in string
+ lpConsoleTitle, // address of buffer for new string
+ nSize, // size of buffer
NULL, // FAST
NULL // FAST
)))
LPCWSTR lpConsoleTitle
)
{
- PCSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ PCSR_API_MESSAGE Request; ULONG CsrRequest;
NTSTATUS Status;
unsigned int c;
HANDLE hConsole;
{
return FALSE;
}
-
- Request = RtlAllocateHeap(GetProcessHeap(),
- HEAP_ZERO_MEMORY,
- sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_SET_TITLE_REQUEST);
+
+ Request = RtlAllocateHeap(RtlGetProcessHeap(), 0,
+ max (sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_SET_TITLE) +
+ min (wcslen(lpConsoleTitle), CSRSS_MAX_TITLE_LENGTH) * sizeof(WCHAR)));
if (Request == NULL)
- {
- CloseHandle(hConsole);
- SetLastError(ERROR_OUTOFMEMORY);
- return(FALSE);
- }
-
- Request->Type = CSRSS_SET_TITLE;
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ return FALSE;
+ }
+
+ CsrRequest = MAKE_CSR_API(SET_TITLE, CSR_CONSOLE);
Request->Data.SetTitleRequest.Console = hConsole;
-
+
for( c = 0; lpConsoleTitle[c] && c < CSRSS_MAX_TITLE_LENGTH; c++ )
Request->Data.SetTitleRequest.Title[c] = lpConsoleTitle[c];
- // add null
- Request->Data.SetTitleRequest.Title[c] = 0;
- Request->Data.SetTitleRequest.Length = c;
+ Request->Data.SetTitleRequest.Length = c * sizeof(WCHAR);
Status = CsrClientCallServer(Request,
- &Reply,
- sizeof(CSRSS_API_REQUEST) +
- c * sizeof(WCHAR),
- sizeof(CSRSS_API_REPLY));
+ NULL,
+ CsrRequest,
+ max (sizeof(CSR_API_MESSAGE), CSR_API_MESSAGE_HEADER_SIZE(CSRSS_SET_TITLE) + c * sizeof(WCHAR)));
CloseHandle(hConsole);
- if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Reply.Status ) )
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Request->Status ) )
{
- RtlFreeHeap( GetProcessHeap(), 0, Request );
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
SetLastErrorByStatus (Status);
return(FALSE);
}
- RtlFreeHeap( GetProcessHeap(), 0, Request );
+
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
+
return TRUE;
}
/*--------------------------------------------------------------
* SetConsoleTitleA
- *
+ *
* 19990204 EA Added
*
* @implemented
LPCSTR lpConsoleTitle
)
{
- PCSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ PCSR_API_MESSAGE Request; ULONG CsrRequest;
NTSTATUS Status;
unsigned int c;
HANDLE hConsole;
{
return FALSE;
}
-
- Request = RtlAllocateHeap(GetProcessHeap(),
- HEAP_ZERO_MEMORY,
- sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_SET_TITLE_REQUEST);
+
+ Request = RtlAllocateHeap(RtlGetProcessHeap(), 0,
+ max (sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_SET_TITLE) +
+ min (strlen(lpConsoleTitle), CSRSS_MAX_TITLE_LENGTH) * sizeof(WCHAR)));
if (Request == NULL)
- {
- CloseHandle(hConsole);
- SetLastError(ERROR_OUTOFMEMORY);
- return(FALSE);
- }
-
- Request->Type = CSRSS_SET_TITLE;
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ return FALSE;
+ }
+
+ CsrRequest = MAKE_CSR_API(SET_TITLE, CSR_CONSOLE);
Request->Data.SetTitleRequest.Console = hConsole;
-
+
for( c = 0; lpConsoleTitle[c] && c < CSRSS_MAX_TITLE_LENGTH; c++ )
Request->Data.SetTitleRequest.Title[c] = lpConsoleTitle[c];
- // add null
- Request->Data.SetTitleRequest.Title[c] = 0;
- Request->Data.SetTitleRequest.Length = c;
+ Request->Data.SetTitleRequest.Length = c * sizeof(WCHAR);
Status = CsrClientCallServer(Request,
- &Reply,
- sizeof(CSRSS_API_REQUEST) +
- c * sizeof(WCHAR),
- sizeof(CSRSS_API_REPLY));
+ NULL,
+ CsrRequest,
+ max (sizeof(CSR_API_MESSAGE), CSR_API_MESSAGE_HEADER_SIZE(CSRSS_SET_TITLE) + c * sizeof(WCHAR)));
CloseHandle(hConsole);
- if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Reply.Status ) )
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Request->Status ) )
{
- RtlFreeHeap( GetProcessHeap(), 0, Request );
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
SetLastErrorByStatus (Status);
return(FALSE);
}
- RtlFreeHeap( GetProcessHeap(), 0, Request );
+
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
+
return TRUE;
}
)
{
// FIXME: don't ignore access, share mode, and security
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
- Request.Type = CSRSS_CREATE_SCREEN_BUFFER;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
- if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ CsrRequest = MAKE_CSR_API(CREATE_SCREEN_BUFFER, CSR_CONSOLE);
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
{
SetLastErrorByStatus ( Status );
return FALSE;
}
- return Reply.Data.CreateScreenBufferReply.OutputHandle;
+ return Request.Data.CreateScreenBufferRequest.OutputHandle;
}
WINAPI
GetConsoleCP( VOID )
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
-
- Request.Type = CSRSS_GET_CONSOLE_CP;
- Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+
+ CsrRequest = MAKE_CSR_API(GET_CONSOLE_CP, CSR_CONSOLE);
+ Status = CsrClientCallServer(&Request, NULL, CsrRequest,
+ sizeof(CSR_API_MESSAGE));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus (Status);
return 0;
}
- return Reply.Data.GetConsoleCodePage.CodePage;
+ return Request.Data.GetConsoleCodePage.CodePage;
}
UINT wCodePageID
)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
-
- Request.Type = CSRSS_SET_CONSOLE_CP;
+
+ CsrRequest = MAKE_CSR_API(SET_CONSOLE_CP, CSR_CONSOLE);
Request.Data.SetConsoleCodePage.CodePage = wCodePageID;
- Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ Status = CsrClientCallServer(&Request, NULL, CsrRequest,
+ sizeof(CSR_API_MESSAGE));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus (Status);
}
WINAPI
GetConsoleOutputCP( VOID )
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
-
- Request.Type = CSRSS_GET_CONSOLE_OUTPUT_CP;
- Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+
+ CsrRequest = MAKE_CSR_API(GET_CONSOLE_OUTPUT_CP, CSR_CONSOLE);
+ Status = CsrClientCallServer(&Request, NULL, CsrRequest,
+ sizeof(CSR_API_MESSAGE));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus (Status);
return 0;
}
- return Reply.Data.GetConsoleOutputCodePage.CodePage;
+ return Request.Data.GetConsoleOutputCodePage.CodePage;
}
UINT wCodePageID
)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
-
- Request.Type = CSRSS_SET_CONSOLE_OUTPUT_CP;
+
+ CsrRequest = MAKE_CSR_API(SET_CONSOLE_OUTPUT_CP, CSR_CONSOLE);
Request.Data.SetConsoleOutputCodePage.CodePage = wCodePageID;
- Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
- sizeof(CSRSS_API_REPLY));
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ Status = CsrClientCallServer(&Request, NULL, CsrRequest,
+ sizeof(CSR_API_MESSAGE));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus (Status);
}
/*--------------------------------------------------------------
* GetConsoleProcessList
*
- * @unimplemented
+ * @implemented
*/
DWORD STDCALL
GetConsoleProcessList(LPDWORD lpdwProcessList,
- DWORD dwProcessCount)
+ DWORD dwProcessCount)
{
- DPRINT1("GetConsoleProcessList(0x%x, 0x%x) UNIMPLEMENTED!\n", lpdwProcessList, dwProcessCount);
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return 0;
+ PCSR_API_MESSAGE Request; ULONG CsrRequest;
+ ULONG nProcesses;
+ NTSTATUS Status;
+
+ if(lpdwProcessList == NULL || dwProcessCount == 0)
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return 0;
+ }
+
+ Request = RtlAllocateHeap(RtlGetProcessHeap(), 0,
+ max (sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_GET_PROCESS_LIST)
+ + min (dwProcessCount, CSRSS_MAX_GET_PROCESS_LIST / sizeof(DWORD)) * sizeof(DWORD)));
+ if (Request == NULL)
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ return FALSE;
+ }
+
+ CsrRequest = MAKE_CSR_API(GET_PROCESS_LIST, CSR_CONSOLE);
+ Request->Data.GetProcessListRequest.nMaxIds = min (dwProcessCount, CSRSS_MAX_GET_PROCESS_LIST / sizeof(DWORD));
+
+ Status = CsrClientCallServer(Request,
+ NULL,
+ CsrRequest,
+ max (sizeof(CSR_API_MESSAGE),
+ CSR_API_MESSAGE_HEADER_SIZE(CSRSS_GET_PROCESS_LIST)
+ + Request->Data.GetProcessListRequest.nMaxIds * sizeof(DWORD)));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request->Status))
+ {
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
+ SetLastErrorByStatus (Status);
+ nProcesses = 0;
+ }
+ else
+ {
+ nProcesses = Request->Data.GetProcessListRequest.nProcessIdsCopied;
+ if(dwProcessCount >= nProcesses)
+ {
+ memcpy(lpdwProcessList, Request->Data.GetProcessListRequest.ProcessId, nProcesses * sizeof(DWORD));
+ }
+ }
+
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Request);
+
+ return nProcesses;
}
*
* @unimplemented
*/
-BOOL STDCALL
+BOOL STDCALL
AttachConsole(DWORD dwProcessId)
{
DPRINT1("AttachConsole(0x%x) UNIMPLEMENTED!\n", dwProcessId);
HWND STDCALL
GetConsoleWindow (VOID)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
+
NTSTATUS Status;
-
- Request.Type = CSRSS_GET_CONSOLE_WINDOW;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
- if (!NT_SUCCESS(Status ) || !NT_SUCCESS(Status = Reply.Status))
+
+ CsrRequest = MAKE_CSR_API(GET_CONSOLE_WINDOW, CSR_CONSOLE);
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
+ if (!NT_SUCCESS(Status ) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus (Status);
return (HWND) NULL;
}
- return Reply.Data.GetConsoleWindowReply.WindowHandle;
+ return Request.Data.GetConsoleWindowRequest.WindowHandle;
}
*/
BOOL STDCALL SetConsoleIcon(HICON hicon)
{
- CSRSS_API_REQUEST Request;
- CSRSS_API_REPLY Reply;
- NTSTATUS Status;
+ CSR_API_MESSAGE Request; ULONG CsrRequest;
- Request.Type = CSRSS_SET_CONSOLE_ICON;
+ NTSTATUS Status;
+
+ CsrRequest = MAKE_CSR_API(SET_CONSOLE_ICON, CSR_CONSOLE);
Request.Data.SetConsoleIconRequest.WindowIcon = hicon;
- Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
- if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
{
SetLastErrorByStatus (Status);
return FALSE;
int lenName = lstrlenW(lpInputExeName);
if(lenName < 1 ||
- lenName > (sizeof(InputExeName) / sizeof(InputExeName[0])) - 1)
+ lenName > (int)(sizeof(InputExeName) / sizeof(InputExeName[0])) - 1)
{
/* Fail if string is empty or too long */
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
-
+
RtlEnterCriticalSection(&ConsoleLock);
/* wrap copying into SEH as we may copy from invalid buffer and in case of an
exception the console lock would've never been released, which would cause
}
_SEH_END;
RtlLeaveCriticalSection(&ConsoleLock);
-
+
return Ret;
}
UNICODE_STRING InputExeNameU;
NTSTATUS Status;
BOOL Ret;
-
+
RtlInitAnsiString(&InputExeNameA, lpInputExeName);
-
+
if(InputExeNameA.Length < sizeof(InputExeNameA.Buffer[0]) ||
InputExeNameA.Length >= (sizeof(InputExeName) / sizeof(InputExeName[0])) - 1)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
-
+
Status = RtlAnsiStringToUnicodeString(&InputExeNameU, &InputExeNameA, TRUE);
if(NT_SUCCESS(Status))
{
RtlEnterCriticalSection(&ConsoleLock);
lenName = lstrlenW(InputExeName);
- if(lenName >= nBufferLength)
+ if(lenName >= (int)nBufferLength)
{
/* buffer is not large enough, return the required size */
RtlLeaveCriticalSection(&ConsoleLock);
SetLastErrorByStatus(_SEH_GetExceptionCode());
}
_SEH_END;
-
+
RtlLeaveCriticalSection(&ConsoleLock);
return lenName;
{
WCHAR *Buffer;
DWORD Ret;
-
+
if(nBufferLength > 0)
{
Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, nBufferLength * sizeof(WCHAR));
{
Buffer = NULL;
}
-
+
Ret = GetConsoleInputExeNameW(nBufferLength, Buffer);
if(nBufferLength > 0)
{
{
UNICODE_STRING BufferU;
ANSI_STRING BufferA;
-
+
RtlInitUnicodeString(&BufferU, Buffer);
BufferA.Length = 0;
BufferA.MaximumLength = nBufferLength;
BufferA.Buffer = lpBuffer;
-
+
RtlUnicodeStringToAnsiString(&BufferA, &BufferU, FALSE);
}
-
+
RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
}
-
+
return Ret;
}
+
+/*--------------------------------------------------------------
+ * GetConsoleHistoryInfo
+ *
+ * @unimplemented
+ */
+BOOL STDCALL
+GetConsoleHistoryInfo(PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo)
+{
+ DPRINT1("GetConsoleHistoryInfo(0x%p) UNIMPLEMENTED!\n", lpConsoleHistoryInfo);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return FALSE;
+}
+
+
+/*--------------------------------------------------------------
+ * SetConsoleHistoryInfo
+ *
+ * @unimplemented
+ */
+BOOL STDCALL
+SetConsoleHistoryInfo(IN PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo)
+{
+ DPRINT1("SetConsoleHistoryInfo(0x%p) UNIMPLEMENTED!\n", lpConsoleHistoryInfo);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return FALSE;
+}
+
+
+/*--------------------------------------------------------------
+ * GetConsoleOriginalTitleW
+ *
+ * @unimplemented
+ */
+DWORD STDCALL
+GetConsoleOriginalTitleW(OUT LPWSTR lpConsoleTitle,
+ IN DWORD nSize)
+{
+ DPRINT1("GetConsoleOriginalTitleW(0x%p, 0x%x) UNIMPLEMENTED!\n", lpConsoleTitle, nSize);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return 0;
+}
+
+
+/*--------------------------------------------------------------
+ * GetConsoleOriginalTitleA
+ *
+ * @unimplemented
+ */
+DWORD STDCALL
+GetConsoleOriginalTitleA(OUT LPSTR lpConsoleTitle,
+ IN DWORD nSize)
+{
+ DPRINT1("GetConsoleOriginalTitleA(0x%p, 0x%x) UNIMPLEMENTED!\n", lpConsoleTitle, nSize);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return 0;
+}
+
+
+/*--------------------------------------------------------------
+ * GetConsoleScreenBufferInfoEx
+ *
+ * @unimplemented
+ */
+BOOL STDCALL
+GetConsoleScreenBufferInfoEx(IN HANDLE hConsoleOutput,
+ OUT PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx)
+{
+ DPRINT1("GetConsoleScreenBufferInfoEx(0x%p, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput, lpConsoleScreenBufferInfoEx);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return FALSE;
+}
+
+
+/*--------------------------------------------------------------
+ * SetConsoleScreenBufferInfoEx
+ *
+ * @unimplemented
+ */
+BOOL STDCALL
+SetConsoleScreenBufferInfoEx(IN HANDLE hConsoleOutput,
+ IN PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx)
+{
+ DPRINT1("SetConsoleScreenBufferInfoEx(0x%p, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput, lpConsoleScreenBufferInfoEx);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return FALSE;
+}
+
+
+/*--------------------------------------------------------------
+ * GetCurrentConsoleFontEx
+ *
+ * @unimplemented
+ */
+BOOL STDCALL
+GetCurrentConsoleFontEx(IN HANDLE hConsoleOutput,
+ IN BOOL bMaximumWindow,
+ OUT PCONSOLE_FONT_INFOEX lpConsoleCurrentFontEx)
+{
+ DPRINT1("GetCurrentConsoleFontEx(0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput, bMaximumWindow, lpConsoleCurrentFontEx);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return FALSE;
+}
+
/* EOF */
projects / reactos.git / blobdiff