/* INCLUDES ******************************************************************/
-#include "w32csr.h"
-
#define NDEBUG
+#include "w32csr.h"
#include <debug.h>
/* GLOBALS *******************************************************************/
#define ConsoleInputUnicodeCharToAnsiChar(Console, dChar, sWChar) \
WideCharToMultiByte((Console)->CodePage, 0, (sWChar), 1, (dChar), 1, NULL, NULL)
+#define ConsoleInputAnsiCharToUnicodeChar(Console, dWChar, sChar) \
+ MultiByteToWideChar((Console)->CodePage, 0, (sChar), 1, (dWChar), 1)
+
#define ConsoleUnicodeCharToAnsiChar(Console, dChar, sWChar) \
WideCharToMultiByte((Console)->OutputCodePage, 0, (sWChar), 1, (dChar), 1, NULL, NULL)
-#define ConsoleAnsiCharToUnicodeChar(Console, sWChar, dChar) \
- MultiByteToWideChar((Console)->OutputCodePage, 0, (dChar), 1, (sWChar), 1)
+#define ConsoleAnsiCharToUnicodeChar(Console, dWChar, sChar) \
+ MultiByteToWideChar((Console)->OutputCodePage, 0, (sChar), 1, (dWChar), 1)
/* FUNCTIONS *****************************************************************/
NTSTATUS FASTCALL
ConioConsoleFromProcessData(PCSRSS_PROCESS_DATA ProcessData, PCSRSS_CONSOLE *Console)
{
- PCSRSS_CONSOLE ProcessConsole = ProcessData->Console;
+ PCSRSS_CONSOLE ProcessConsole;
+
+ RtlEnterCriticalSection(&ProcessData->HandleTableLock);
+ ProcessConsole = ProcessData->Console;
if (!ProcessConsole)
{
*Console = NULL;
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
return STATUS_INVALID_HANDLE;
}
InterlockedIncrement(&ProcessConsole->Header.ReferenceCount);
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
EnterCriticalSection(&(ProcessConsole->Header.Lock));
*Console = ProcessConsole;
Thread = CreateRemoteThread(ProcessData->Process, NULL, 0,
(LPTHREAD_START_ROUTINE) ProcessData->CtrlDispatcher,
- (PVOID) Event, 0, NULL);
+ UlongToPtr(Event), 0, NULL);
if (NULL == Thread)
{
DPRINT1("Failed thread creation (Error: 0x%x)\n", GetLastError());
ConioConsoleCtrlEventTimeout(Event, ProcessData, 0);
}
-DWORD FASTCALL
-ConioGetBufferOffset(PCSRSS_SCREEN_BUFFER Buff, ULONG X, ULONG Y)
+PBYTE FASTCALL
+ConioCoordToPointer(PCSRSS_SCREEN_BUFFER Buff, ULONG X, ULONG Y)
{
- return 2 * (((Y + Buff->VirtualY) % Buff->MaxY) * Buff->MaxX + X);
+ return &Buff->Buffer[2 * (((Y + Buff->VirtualY) % Buff->MaxY) * Buff->MaxX + X)];
}
-#define GET_CELL_BUFFER(b,o)\
-(b)->Buffer[(o)++]
-
-#define SET_CELL_BUFFER(b,o,c,a)\
-(b)->Buffer[(o)++]=(c),\
-(b)->Buffer[(o)++]=(a)
-
static VOID FASTCALL
ClearLineBuffer(PCSRSS_SCREEN_BUFFER Buff)
{
- DWORD Offset = ConioGetBufferOffset(Buff, 0, Buff->CurrentY);
+ PBYTE Ptr = ConioCoordToPointer(Buff, 0, Buff->CurrentY);
UINT Pos;
for (Pos = 0; Pos < Buff->MaxX; Pos++)
{
- /* Fill the cell: Offset is incremented by the macro */
- SET_CELL_BUFFER(Buff, Offset, ' ', Buff->DefaultAttrib);
+ /* Fill the cell */
+ *Ptr++ = ' ';
+ *Ptr++ = Buff->DefaultAttrib;
}
}
return STATUS_SUCCESS;
}
-static NTSTATUS STDCALL
+static NTSTATUS WINAPI
CsrInitConsole(PCSRSS_CONSOLE Console)
{
NTSTATUS Status;
}
/* init screen buffer with defaults */
NewBuffer->CursorInfo.bVisible = TRUE;
- NewBuffer->CursorInfo.dwSize = 5;
+ NewBuffer->CursorInfo.dwSize = CSR_DEFAULT_CURSOR_SIZE;
/* make console active, and insert into console list */
Console->ActiveBuffer = (PCSRSS_SCREEN_BUFFER) NewBuffer;
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
- if (ProcessData == NULL)
- {
- DPRINT1("No process data\n");
- return Request->Status = STATUS_INVALID_PARAMETER;
- }
-
+ RtlEnterCriticalSection(&ProcessData->HandleTableLock);
if (ProcessData->Console)
{
DPRINT1("Process already has a console\n");
- Request->Status = STATUS_INVALID_PARAMETER;
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
return STATUS_INVALID_PARAMETER;
}
- /* Assume success */
- Request->Status = STATUS_SUCCESS;
-
/* If we don't need a console, then get out of here */
if (!Request->Data.AllocConsoleRequest.ConsoleNeeded)
{
DPRINT("No console needed\n");
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
return STATUS_SUCCESS;
}
if (NULL == Console)
{
DPRINT1("Not enough memory for console\n");
- Request->Status = STATUS_NO_MEMORY;
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
return STATUS_NO_MEMORY;
}
/* initialize list head */
/* insert process data required for GUI initialization */
InsertHeadList(&Console->ProcessList, &ProcessData->ProcessEntry);
/* Initialize the Console */
- Request->Status = CsrInitConsole(Console);
- if (!NT_SUCCESS(Request->Status))
+ Status = CsrInitConsole(Console);
+ if (!NT_SUCCESS(Status))
{
DPRINT1("Console init failed\n");
HeapFree(Win32CsrApiHeap, 0, Console);
- return Request->Status;
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
+ return Status;
}
}
else
DPRINT1("Failed to insert object\n");
ConioDeleteConsole((Object_t *) Console);
ProcessData->Console = 0;
- return Request->Status = Status;
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
+ return Status;
}
Status = Win32CsrInsertObject(ProcessData,
Win32CsrReleaseObject(ProcessData,
Request->Data.AllocConsoleRequest.InputHandle);
ProcessData->Console = 0;
- return Request->Status = Status;
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
+ return Status;
}
}
Request->Data.AllocConsoleRequest.InputHandle);
}
ProcessData->Console = 0;
- return Request->Status = Status;
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
+ return Status;
}
/* Set the Ctrl Dispatcher */
InsertHeadList(&ProcessData->Console->ProcessList, &ProcessData->ProcessEntry);
}
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
return STATUS_SUCCESS;
}
CSR_API(CsrFreeConsole)
{
- PCSRSS_CONSOLE Console;
-
-
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
- if (ProcessData == NULL || ProcessData->Console == NULL)
- {
- return Request->Status = STATUS_INVALID_PARAMETER;
- }
-
- Console = ProcessData->Console;
- ProcessData->Console = NULL;
- RemoveEntryList(&ProcessData->ProcessEntry);
- if (0 == InterlockedDecrement(&Console->Header.ReferenceCount))
- {
- ConioDeleteConsole((Object_t *) Console);
- }
- return STATUS_SUCCESS;
+ return Win32CsrReleaseConsole(ProcessData);
}
static VOID FASTCALL
CHAR *Buffer, DWORD Length, BOOL Attrib)
{
UINT i;
- DWORD Offset;
+ PBYTE Ptr;
RECT UpdateRect;
LONG CursorStartX, CursorStartY;
UINT ScrolledLines;
{
Buff->CurrentX--;
}
- Offset = ConioGetBufferOffset(Buff, Buff->CurrentX, Buff->CurrentY);
- SET_CELL_BUFFER(Buff, Offset, ' ', Buff->DefaultAttrib);
+ Ptr = ConioCoordToPointer(Buff, Buff->CurrentX, Buff->CurrentY);
+ Ptr[0] = ' ';
+ Ptr[1] = Buff->DefaultAttrib;
UpdateRect.left = min(UpdateRect.left, (LONG) Buff->CurrentX);
UpdateRect.right = max(UpdateRect.right, (LONG) Buff->CurrentX);
}
{
EndX = Buff->MaxX;
}
- Offset = ConioGetBufferOffset(Buff, Buff->CurrentX, Buff->CurrentY);
+ Ptr = ConioCoordToPointer(Buff, Buff->CurrentX, Buff->CurrentY);
while (Buff->CurrentX < EndX)
{
- Buff->Buffer[Offset] = ' ';
- Buff->Buffer[Offset + 1] = Buff->DefaultAttrib;
- Offset += 2;
+ *Ptr++ = ' ';
+ *Ptr++ = Buff->DefaultAttrib;
Buff->CurrentX++;
}
UpdateRect.right = max(UpdateRect.right, (LONG) Buff->CurrentX - 1);
}
UpdateRect.left = min(UpdateRect.left, (LONG)Buff->CurrentX);
UpdateRect.right = max(UpdateRect.right, (LONG) Buff->CurrentX);
- Offset = ConioGetBufferOffset(Buff, Buff->CurrentX, Buff->CurrentY);
- Buff->Buffer[Offset++] = Buffer[i];
+ Ptr = ConioCoordToPointer(Buff, Buff->CurrentX, Buff->CurrentY);
+ Ptr[0] = Buffer[i];
if (Attrib)
{
- Buff->Buffer[Offset] = Buff->DefaultAttrib;
+ Ptr[1] = Buff->DefaultAttrib;
}
Buff->CurrentX++;
if (Buff->CurrentX == Buff->MaxX)
&Console, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Request->Data.ReadConsoleRequest.EventHandle = ProcessData->ConsoleEvent;
for (i = 0; i < nNumberOfCharsToRead && Console->InputEvents.Flink != &Console->InputEvents; i++)
CurrentEntry = RemoveHeadList(&Console->InputEvents);
if (IsListEmpty(&Console->InputEvents))
{
- CHECKPOINT;
ResetEvent(Console->ActiveEvent);
}
Input = CONTAINING_RECORD(CurrentEntry, ConsoleInput, ListEntry);
ConioUnlockConsole(Console);
HeapFree(Win32CsrApiHeap, 0, Input);
Request->Data.ReadConsoleRequest.NrCharactersRead = 0;
- Request->Status = STATUS_NOTIFY_CLEANUP;
return STATUS_NOTIFY_CLEANUP;
}
else
{
if(Request->Data.ReadConsoleRequest.Unicode)
- UnicodeBuffer[i] = Input->InputEvent.Event.KeyEvent.uChar.AsciiChar; /* FIXME */
+ ConsoleInputAnsiCharToUnicodeChar(Console, &UnicodeBuffer[i], &Input->InputEvent.Event.KeyEvent.uChar.AsciiChar);
else
Buffer[i] = Input->InputEvent.Event.KeyEvent.uChar.AsciiChar;
}
Request->Data.ReadConsoleRequest.NrCharactersRead = i;
if (0 == i)
{
- Request->Status = STATUS_PENDING; /* we didn't read anything */
+ Status = STATUS_PENDING; /* we didn't read anything */
}
else if (0 != (Console->Mode & ENABLE_LINE_INPUT))
{
if (0 == Console->WaitingLines ||
(Request->Data.ReadConsoleRequest.Unicode ? (L'\n' != UnicodeBuffer[i - 1]) : ('\n' != Buffer[i - 1])))
{
- Request->Status = STATUS_PENDING; /* line buffered, didn't get a complete line */
+ Status = STATUS_PENDING; /* line buffered, didn't get a complete line */
}
else
{
Console->WaitingLines--;
- Request->Status = STATUS_SUCCESS; /* line buffered, did get a complete line */
+ Status = STATUS_SUCCESS; /* line buffered, did get a complete line */
}
}
else
{
- Request->Status = STATUS_SUCCESS; /* not line buffered, did read something */
+ Status = STATUS_SUCCESS; /* not line buffered, did read something */
}
- if (Request->Status == STATUS_PENDING)
+ if (Status == STATUS_PENDING)
{
Console->EchoCount = nNumberOfCharsToRead - i;
}
Request->Header.u1.s1.DataLength = Request->Header.u1.s1.TotalLength - sizeof(PORT_MESSAGE);
}
- return Request->Status;
+ return Status;
}
-BOOLEAN __inline ConioGetIntersection(
+__inline BOOLEAN ConioGetIntersection(
RECT *Intersection,
RECT *Rect1,
RECT *Rect2)
return TRUE;
}
-BOOLEAN __inline ConioGetUnion(
+__inline BOOLEAN ConioGetUnion(
RECT *Union,
RECT *Rect1,
RECT *Rect2)
}
for (i = 0; i < Height; i++)
{
- PWORD SRow = (PWORD)&ScreenBuffer->Buffer[ConioGetBufferOffset(ScreenBuffer, 0, SY)];
- PWORD DRow = (PWORD)&ScreenBuffer->Buffer[ConioGetBufferOffset(ScreenBuffer, 0, DY)];
+ PWORD SRow = (PWORD)ConioCoordToPointer(ScreenBuffer, 0, SY);
+ PWORD DRow = (PWORD)ConioCoordToPointer(ScreenBuffer, 0, DY);
SX = SrcRegion->left;
DX = DstRegion->left;
DPRINT1("Invalid request size\n");
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
- return Request->Status = STATUS_INVALID_PARAMETER;
+ return STATUS_INVALID_PARAMETER;
}
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
if(Request->Data.WriteConsoleRequest.Unicode)
Status = ConioLockScreenBuffer(ProcessData, Request->Data.WriteConsoleRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
if (NT_SUCCESS(Status))
{
- Request->Status = ConioWriteConsole(Console, Buff, Buffer,
- Request->Data.WriteConsoleRequest.NrCharactersToWrite, TRUE);
+ Status = ConioWriteConsole(Console, Buff, Buffer,
+ Request->Data.WriteConsoleRequest.NrCharactersToWrite, TRUE);
if (NT_SUCCESS(Status))
{
Written = Request->Data.WriteConsoleRequest.NrCharactersToWrite;
Request->Data.WriteConsoleRequest.NrCharactersWritten = Written;
- return Request->Status = Status;
+ return Status;
}
-VOID STDCALL
+VOID WINAPI
ConioDeleteScreenBuffer(Object_t *Object)
{
PCSRSS_SCREEN_BUFFER Buffer = (PCSRSS_SCREEN_BUFFER) Object;
}
-VOID STDCALL
+VOID WINAPI
ConioDeleteConsole(Object_t *Object)
{
PCSRSS_CONSOLE Console = (PCSRSS_CONSOLE) Object;
HeapFree(Win32CsrApiHeap, 0, Console);
}
-VOID STDCALL
+VOID WINAPI
CsrInitConsoleSupport(VOID)
{
DPRINT("CSR: CsrInitConsoleSupport()\n");
ConsoleInput *KeyEventRecord)
{
BOOL updown;
- BOOL bClientWake = FALSE;
ConsoleInput *TempInput;
if (0 != (Console->Mode & (ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT)))
{
Console->WaitingLines++;
}
- bClientWake = TRUE;
- SetEvent(Console->ActiveEvent);
}
KeyEventRecord->Echoed = FALSE;
if (0 != (Console->Mode & (ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT))
RemoveEntryList(&KeyEventRecord->ListEntry);
HeapFree(Win32CsrApiHeap, 0, KeyEventRecord);
Console->WaitingChars -= 2;
- }
- else
- {
- SetEvent(Console->ActiveEvent);
+ return;
}
}
else
}
/* Console->WaitingChars++; */
- if (bClientWake || 0 == (Console->Mode & ENABLE_LINE_INPUT))
- {
- SetEvent(Console->ActiveEvent);
- }
+ SetEvent(Console->ActiveEvent);
}
static DWORD FASTCALL
return ssOut;
}
-VOID STDCALL
+VOID WINAPI
ConioProcessKey(MSG *msg, PCSRSS_CONSOLE Console, BOOL TextMode)
{
static BYTE KeyState[256] = { 0 };
CSR_API(CsrGetScreenBufferInfo)
{
NTSTATUS Status;
+ PCSRSS_CONSOLE Console;
PCSRSS_SCREEN_BUFFER Buff;
PCONSOLE_SCREEN_BUFFER_INFO pInfo;
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
+ Status = ConioConsoleFromProcessData(ProcessData, &Console);
+ if (! NT_SUCCESS(Status))
+ {
+ return Status;
+ }
Status = ConioLockScreenBuffer(ProcessData, Request->Data.ScreenBufferInfoRequest.ConsoleHandle, &Buff, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ ConioUnlockConsole(Console);
+ return Status;
}
pInfo = &Request->Data.ScreenBufferInfoRequest.Info;
pInfo->dwSize.X = Buff->MaxX;
pInfo->dwCursorPosition.X = Buff->CurrentX;
pInfo->dwCursorPosition.Y = Buff->CurrentY;
pInfo->wAttributes = Buff->DefaultAttrib;
- pInfo->srWindow.Left = 0;
- pInfo->srWindow.Right = Buff->MaxX - 1;
- pInfo->srWindow.Top = 0;
- pInfo->srWindow.Bottom = Buff->MaxY - 1;
+ pInfo->srWindow.Left = Buff->ShowX;
+ pInfo->srWindow.Right = Buff->ShowX + Console->Size.X - 1;
+ pInfo->srWindow.Top = Buff->ShowY;
+ pInfo->srWindow.Bottom = Buff->ShowY + Console->Size.Y - 1;
pInfo->dwMaximumWindowSize.X = Buff->MaxX;
pInfo->dwMaximumWindowSize.Y = Buff->MaxY;
ConioUnlockScreenBuffer(Buff);
+ ConioUnlockConsole(Console);
- Request->Status = STATUS_SUCCESS;
-
- return Request->Status;
+ return STATUS_SUCCESS;
}
CSR_API(CsrSetCursor)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
if (! NT_SUCCESS(Status))
{
ConioUnlockConsole(Console);
- return Request->Status = Status;
+ return Status;
}
NewCursorX = Request->Data.SetCursorRequest.Position.X;
{
ConioUnlockScreenBuffer(Buff);
ConioUnlockConsole(Console);
- return Request->Status = STATUS_INVALID_PARAMETER;
+ return STATUS_INVALID_PARAMETER;
}
OldCursorX = Buff->CurrentX;
OldCursorY = Buff->CurrentY;
{
ConioUnlockScreenBuffer(Buff);
ConioUnlockConsole(Console);
- return Request->Status = STATUS_UNSUCCESSFUL;
+ return STATUS_UNSUCCESSFUL;
}
}
ConioUnlockScreenBuffer(Buff);
ConioUnlockConsole(Console);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
static VOID FASTCALL
DPRINT1("Invalid request size\n");
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
- return Request->Status = STATUS_INVALID_PARAMETER;
+ return STATUS_INVALID_PARAMETER;
}
Status = ConioConsoleFromProcessData(ProcessData, &Console);
ConioUnlockConsole(Console);
}
Request->Data.WriteConsoleOutputCharRequest.NrCharactersWritten = Written;
- return Request->Status = Status;
+ return Status;
}
CSR_API(CsrFillOutputChar)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Status = ConioLockScreenBuffer(ProcessData, Request->Data.FillOutputRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
if (! NT_SUCCESS(Status))
{
ConioUnlockConsole(Console);
- return Request->Status = Status;
+ return Status;
}
X = Request->Data.FillOutputRequest.Position.X;
ConioUnlockConsole(Console);
Length = Request->Data.FillOutputRequest.Length;
Request->Data.FillOutputRequest.NrCharactersWritten = Length;
- return Request->Status;
+ return STATUS_SUCCESS;
}
CSR_API(CsrReadInputEvent)
Status = ConioLockConsole(ProcessData, Request->Data.ReadInputRequest.ConsoleHandle, &Console, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
/* only get input if there is any */
ConioUnlockConsole(Console);
- return Request->Status = Status;
+ return Status;
}
CSR_API(CsrWriteConsoleOutputAttrib)
DPRINT1("Invalid request size\n");
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
- return Request->Status = STATUS_INVALID_PARAMETER;
+ return STATUS_INVALID_PARAMETER;
}
Status = ConioConsoleFromProcessData(ProcessData, &Console);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Status = ConioLockScreenBuffer(ProcessData,
if (! NT_SUCCESS(Status))
{
ConioUnlockConsole(Console);
- return Request->Status = Status;
+ return Status;
}
X = Request->Data.WriteConsoleOutputAttribRequest.Coord.X;
ConioUnlockScreenBuffer(Buff);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
CSR_API(CsrFillOutputAttrib)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
if (! NT_SUCCESS(Status))
{
ConioUnlockConsole(Console);
- return Request->Status = Status;
+ return Status;
}
X = Request->Data.FillOutputAttribRequest.Coord.X;
ConioUnlockScreenBuffer(Buff);
ConioUnlockConsole(Console);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
Status = ConioLockScreenBuffer(ProcessData, Request->Data.GetCursorInfoRequest.ConsoleHandle, &Buff, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Request->Data.GetCursorInfoRequest.Info.bVisible = Buff->CursorInfo.bVisible;
Request->Data.GetCursorInfoRequest.Info.dwSize = Buff->CursorInfo.dwSize;
ConioUnlockScreenBuffer(Buff);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
CSR_API(CsrSetCursorInfo)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetCursorInfoRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
if (! NT_SUCCESS(Status))
{
ConioUnlockConsole(Console);
- return Request->Status = Status;
+ return Status;
}
Size = Request->Data.SetCursorInfoRequest.Info.dwSize;
{
ConioUnlockScreenBuffer(Buff);
ConioUnlockConsole(Console);
- return Request->Status = STATUS_UNSUCCESSFUL;
+ return STATUS_UNSUCCESSFUL;
}
}
ConioUnlockScreenBuffer(Buff);
ConioUnlockConsole(Console);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
CSR_API(CsrSetTextAttrib)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetCursorRequest.ConsoleHandle, &Buff, GENERIC_WRITE);
if (! NT_SUCCESS(Status))
{
ConioUnlockConsole(Console);
- return Request->Status = Status;
+ return Status;
}
Buff->DefaultAttrib = Request->Data.SetAttribRequest.Attrib;
{
ConioUnlockScreenBuffer(Buff);
ConioUnlockConsole(Console);
- return Request->Status = STATUS_UNSUCCESSFUL;
+ return STATUS_UNSUCCESSFUL;
}
}
ConioUnlockScreenBuffer(Buff);
ConioUnlockConsole(Console);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
CSR_API(CsrSetConsoleMode)
(Object_t **) &Console, GENERIC_WRITE);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Buff = (PCSRSS_SCREEN_BUFFER)Console;
Win32CsrReleaseObjectByPointer((Object_t *)Console);
- return Request->Status = Status;
+ return Status;
}
CSR_API(CsrGetConsoleMode)
(Object_t **) &Console, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
- Request->Status = STATUS_SUCCESS;
+ Status = STATUS_SUCCESS;
Buff = (PCSRSS_SCREEN_BUFFER) Console;
if (CONIO_CONSOLE_MAGIC == Console->Header.Type)
{
}
else
{
- Request->Status = STATUS_INVALID_HANDLE;
+ Status = STATUS_INVALID_HANDLE;
}
Win32CsrReleaseObjectByPointer((Object_t *)Console);
- return Request->Status;
+ return Status;
}
CSR_API(CsrCreateScreenBuffer)
DPRINT("CsrCreateScreenBuffer\n");
- if (ProcessData == NULL)
- {
- return Request->Status = STATUS_INVALID_PARAMETER;
- }
-
+ RtlEnterCriticalSection(&ProcessData->HandleTableLock);
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
else
{
Buff->CursorInfo.bVisible = TRUE;
- Buff->CursorInfo.dwSize = 5;
+ Buff->CursorInfo.dwSize = CSR_DEFAULT_CURSOR_SIZE;
}
if (Buff->MaxX == 0)
}
Status = CsrInitConsoleScreenBuffer(Console, Buff);
- if(! NT_SUCCESS(Status))
+ if(NT_SUCCESS(Status))
{
- Request->Status = Status;
- }
- else
- {
- Request->Status = Win32CsrInsertObject(ProcessData,
+ Status = Win32CsrInsertObject(ProcessData,
&Request->Data.CreateScreenBufferRequest.OutputHandle,
&Buff->Header,
Request->Data.CreateScreenBufferRequest.Access,
}
else
{
- Request->Status = STATUS_INSUFFICIENT_RESOURCES;
+ Status = STATUS_INSUFFICIENT_RESOURCES;
}
ConioUnlockConsole(Console);
- return Request->Status;
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
+ return Status;
}
CSR_API(CsrSetScreenBuffer)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
if (! NT_SUCCESS(Status))
{
ConioUnlockConsole(Console);
- return Request->Status = Status;
+ return Status;
}
if (Buff == Console->ActiveBuffer)
{
ConioUnlockScreenBuffer(Buff);
ConioUnlockConsole(Console);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
/* drop reference to old buffer, maybe delete */
ConioUnlockScreenBuffer(Buff);
ConioUnlockConsole(Console);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
CSR_API(CsrSetTitle)
DPRINT1("Invalid request size\n");
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
- return Request->Status = STATUS_INVALID_PARAMETER;
+ return STATUS_INVALID_PARAMETER;
}
Status = ConioConsoleFromProcessData(ProcessData, &Console);
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
- if(! NT_SUCCESS(Status))
- {
- Request->Status = Status;
- }
- else
+ if(NT_SUCCESS(Status))
{
Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, Request->Data.SetTitleRequest.Length);
if (Buffer)
memcpy(Console->Title.Buffer, Request->Data.SetTitleRequest.Title, Console->Title.Length);
if (! ConioChangeTitle(Console))
{
- Request->Status = STATUS_UNSUCCESSFUL;
+ Status = STATUS_UNSUCCESSFUL;
}
else
{
- Request->Status = STATUS_SUCCESS;
+ Status = STATUS_SUCCESS;
}
}
else
{
- Request->Status = STATUS_NO_MEMORY;
+ Status = STATUS_NO_MEMORY;
}
ConioUnlockConsole(Console);
}
- return Request->Status;
+ return Status;
}
CSR_API(CsrGetTitle)
if (! NT_SUCCESS(Status))
{
DPRINT1("Can't get console\n");
- return Request->Status = Status;
+ return Status;
}
/* Copy title of the console to the user title buffer */
Request->Header.u1.s1.TotalLength = Length;
Request->Header.u1.s1.DataLength = Length - sizeof(PORT_MESSAGE);
}
- Request->Status = STATUS_SUCCESS;
-
- return Request->Status;
+ return STATUS_SUCCESS;
}
CSR_API(CsrWriteConsoleOutput)
COORD BufferCoord;
COORD BufferSize;
NTSTATUS Status;
- DWORD Offset;
+ PBYTE Ptr;
DWORD PSize;
DPRINT("CsrWriteConsoleOutput\n");
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
if (! NT_SUCCESS(Status))
{
ConioUnlockConsole(Console);
- return Request->Status = Status;
+ return Status;
}
BufferSize = Request->Data.WriteConsoleOutputRequest.BufferSize;
{
ConioUnlockScreenBuffer(Buff);
ConioUnlockConsole(Console);
- return Request->Status = STATUS_ACCESS_VIOLATION;
+ return STATUS_ACCESS_VIOLATION;
}
WriteRegion.left = Request->Data.WriteConsoleOutputRequest.WriteRegion.Left;
WriteRegion.top = Request->Data.WriteConsoleOutputRequest.WriteRegion.Top;
/* It is okay to have a WriteRegion completely outside the screen buffer.
No data is written then. */
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
for (i = 0, Y = WriteRegion.top; Y <= WriteRegion.bottom; i++, Y++)
{
CurCharInfo = CharInfo + (i + BufferCoord.Y) * BufferSize.X + BufferCoord.X;
- Offset = ConioGetBufferOffset(Buff, WriteRegion.left, Y);
+ Ptr = ConioCoordToPointer(Buff, WriteRegion.left, Y);
for (X = WriteRegion.left; X <= WriteRegion.right; X++)
{
+ CHAR AsciiChar;
if (Request->Data.WriteConsoleOutputRequest.Unicode)
{
- CHAR AsciiChar;
ConsoleUnicodeCharToAnsiChar(Console, &AsciiChar, &CurCharInfo->Char.UnicodeChar);
- SET_CELL_BUFFER(Buff, Offset, AsciiChar, CurCharInfo->Attributes);
}
else
{
- SET_CELL_BUFFER(Buff, Offset, CurCharInfo->Char.AsciiChar, CurCharInfo->Attributes);
+ AsciiChar = CurCharInfo->Char.AsciiChar;
}
+ *Ptr++ = AsciiChar;
+ *Ptr++ = CurCharInfo->Attributes;
CurCharInfo++;
}
}
Request->Data.WriteConsoleOutputRequest.WriteRegion.Left = WriteRegion.left;
Request->Data.WriteConsoleOutputRequest.WriteRegion.Top = WriteRegion.top;
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
CSR_API(CsrFlushInputBuffer)
GENERIC_WRITE);
if(! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
/* Discard all entries in the input event queue */
ConioUnlockConsole(Console);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
CSR_API(CsrScrollConsoleScreenBuffer)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
if (! NT_SUCCESS(Status))
{
ConioUnlockConsole(Console);
- return Request->Status = Status;
+ return Status;
}
ScrollRectangle.left = Request->Data.ScrollConsoleScreenBufferRequest.ScrollRectangle.Left;
{
ConioUnlockScreenBuffer(Buff);
ConioUnlockConsole(Console);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
/* If the source was clipped on the left or top, adjust the destination accordingly */
{
ConioUnlockConsole(Console);
ConioUnlockScreenBuffer(Buff);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
}
else
ConioUnlockScreenBuffer(Buff);
ConioUnlockConsole(Console);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
CSR_API(CsrReadConsoleOutputChar)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Status = ConioLockScreenBuffer(ProcessData, Request->Data.ReadConsoleOutputCharRequest.ConsoleHandle, &Buff, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
ConioUnlockConsole(Console);
- return Request->Status = Status;
+ return Status;
}
Xpos = Request->Data.ReadConsoleOutputCharRequest.ReadCoord.X;
}
*ReadBuffer = 0;
- Request->Status = STATUS_SUCCESS;
Request->Data.ReadConsoleOutputCharRequest.EndCoord.X = Xpos;
Request->Data.ReadConsoleOutputCharRequest.EndCoord.Y = (Ypos - Buff->VirtualY + Buff->MaxY) % Buff->MaxY;
Request->Header.u1.s1.DataLength = Request->Header.u1.s1.TotalLength - sizeof(PORT_MESSAGE);
}
- return Request->Status;
+ return STATUS_SUCCESS;
}
Status = ConioLockScreenBuffer(ProcessData, Request->Data.ReadConsoleOutputAttribRequest.ConsoleHandle, &Buff, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Xpos = Request->Data.ReadConsoleOutputAttribRequest.ReadCoord.X;
*ReadBuffer = 0;
- Request->Status = STATUS_SUCCESS;
Request->Data.ReadConsoleOutputAttribRequest.EndCoord.X = Xpos;
Request->Data.ReadConsoleOutputAttribRequest.EndCoord.Y = (Ypos - Buff->VirtualY + Buff->MaxY) % Buff->MaxY;
Request->Header.u1.s1.DataLength = CurrentLength - sizeof(PORT_MESSAGE);
}
- return Request->Status;
+ return STATUS_SUCCESS;
}
Status = ConioLockConsole(ProcessData, Request->Data.GetNumInputEventsRequest.ConsoleHandle, &Console, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
CurrentItem = Console->InputEvents.Flink;
ConioUnlockConsole(Console);
- Request->Status = STATUS_SUCCESS;
Request->Data.GetNumInputEventsRequest.NumInputEvents = NumEvents;
- return Request->Status;
+ return STATUS_SUCCESS;
}
Status = ConioLockConsole(ProcessData, Request->Data.GetNumInputEventsRequest.ConsoleHandle, &Console, GENERIC_READ);
if(! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
InputRecord = Request->Data.PeekConsoleInputRequest.InputRecord;
|| (((ULONG_PTR)InputRecord + Size) > ((ULONG_PTR)ProcessData->CsrSectionViewBase + ProcessData->CsrSectionViewSize)))
{
ConioUnlockConsole(Console);
- Request->Status = STATUS_ACCESS_VIOLATION;
- return Request->Status ;
+ return STATUS_ACCESS_VIOLATION;
}
NumItems = 0;
ConioUnlockConsole(Console);
- Request->Status = STATUS_SUCCESS;
Request->Data.PeekConsoleInputRequest.Length = NumItems;
- return Request->Status;
+ return STATUS_SUCCESS;
}
COORD BufferCoord;
RECT ReadRegion;
RECT ScreenRect;
- DWORD i, Offset;
+ DWORD i;
+ PBYTE Ptr;
LONG X, Y;
UINT CodePage;
Status = ConioLockScreenBuffer(ProcessData, Request->Data.ReadConsoleOutputRequest.ConsoleHandle, &Buff, GENERIC_READ);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
CharInfo = Request->Data.ReadConsoleOutputRequest.CharInfo;
|| (((ULONG_PTR)CharInfo + Size) > ((ULONG_PTR)ProcessData->CsrSectionViewBase + ProcessData->CsrSectionViewSize)))
{
ConioUnlockScreenBuffer(Buff);
- Request->Status = STATUS_ACCESS_VIOLATION;
- return Request->Status ;
+ return STATUS_ACCESS_VIOLATION;
}
SizeY = min(BufferSize.Y - BufferCoord.Y, ConioRectHeight(&ReadRegion));
if (! ConioGetIntersection(&ReadRegion, &ScreenRect, &ReadRegion))
{
ConioUnlockScreenBuffer(Buff);
- Request->Status = STATUS_SUCCESS;
- return Request->Status;
+ return STATUS_SUCCESS;
}
for (i = 0, Y = ReadRegion.top; Y < ReadRegion.bottom; ++i, ++Y)
{
CurCharInfo = CharInfo + (i * BufferSize.X);
- Offset = ConioGetBufferOffset(Buff, ReadRegion.left, Y);
+ Ptr = ConioCoordToPointer(Buff, ReadRegion.left, Y);
for (X = ReadRegion.left; X < ReadRegion.right; ++X)
{
if (Request->Data.ReadConsoleOutputRequest.Unicode)
{
MultiByteToWideChar(CodePage, 0,
- (PCHAR)&GET_CELL_BUFFER(Buff, Offset), 1,
+ (PCHAR)Ptr++, 1,
&CurCharInfo->Char.UnicodeChar, 1);
}
else
{
- CurCharInfo->Char.AsciiChar = GET_CELL_BUFFER(Buff, Offset);
+ CurCharInfo->Char.AsciiChar = *Ptr++;
}
- CurCharInfo->Attributes = GET_CELL_BUFFER(Buff, Offset);
+ CurCharInfo->Attributes = *Ptr++;
++CurCharInfo;
}
}
ConioUnlockScreenBuffer(Buff);
- Request->Status = STATUS_SUCCESS;
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;
- return Request->Status;
+ return STATUS_SUCCESS;
}
Status = ConioLockConsole(ProcessData, Request->Data.WriteConsoleInputRequest.ConsoleHandle, &Console, GENERIC_WRITE);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
InputRecord = Request->Data.WriteConsoleInputRequest.InputRecord;
|| (((ULONG_PTR)InputRecord + Size) > ((ULONG_PTR)ProcessData->CsrSectionViewBase + ProcessData->CsrSectionViewSize)))
{
ConioUnlockConsole(Console);
- Request->Status = STATUS_ACCESS_VIOLATION;
- return Request->Status ;
+ return STATUS_ACCESS_VIOLATION;
}
for (i = 0; i < Length; i++)
if (NULL == Record)
{
ConioUnlockConsole(Console);
- Request->Status = STATUS_INSUFFICIENT_RESOURCES;
- return Request->Status;
+ return STATUS_INSUFFICIENT_RESOURCES;
}
Record->Echoed = FALSE;
ConioUnlockConsole(Console);
- Request->Status = STATUS_SUCCESS;
Request->Data.WriteConsoleInputRequest.Length = i;
- return Request->Status;
+ return STATUS_SUCCESS;
}
/**********************************************************************
if (! NT_SUCCESS(Status))
{
DPRINT1("Failed to get console handle in SetConsoleHardwareState\n");
- return Request->Status = Status;
+ return Status;
}
switch (Request->Data.ConsoleHardwareStateRequest.SetGet)
case CONSOLE_HARDWARE_STATE_SET:
DPRINT("Setting console hardware state.\n");
- Request->Status = SetConsoleHardwareState(Console, Request->Data.ConsoleHardwareStateRequest.State);
+ Status = SetConsoleHardwareState(Console, Request->Data.ConsoleHardwareStateRequest.State);
break;
default:
- Request->Status = STATUS_INVALID_PARAMETER_2; /* Client: (handle, [set_get], mode) */
+ Status = STATUS_INVALID_PARAMETER_2; /* Client: (handle, [set_get], mode) */
break;
}
ConioUnlockConsole(Console);
- return Request->Status;
+ return Status;
}
CSR_API(CsrGetConsoleWindow)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Request->Data.GetConsoleWindowRequest.WindowHandle = Console->hWindow;
ConioUnlockConsole(Console);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
CSR_API(CsrSetConsoleIcon)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
- Request->Status = (ConioChangeIcon(Console, Request->Data.SetConsoleIconRequest.WindowIcon)
- ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
+ Status = (ConioChangeIcon(Console, Request->Data.SetConsoleIconRequest.WindowIcon)
+ ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
ConioUnlockConsole(Console);
- return Request->Status;
+ return Status;
}
CSR_API(CsrGetConsoleCodePage)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
Request->Data.GetConsoleCodePage.CodePage = Console->CodePage;
ConioUnlockConsole(Console);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
CSR_API(CsrSetConsoleCodePage)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
+
if (IsValidCodePage(Request->Data.SetConsoleCodePage.CodePage))
{
Console->CodePage = Request->Data.SetConsoleCodePage.CodePage;
ConioUnlockConsole(Console);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
+
ConioUnlockConsole(Console);
- return Request->Status = STATUS_UNSUCCESSFUL;
+ return STATUS_INVALID_PARAMETER;
}
CSR_API(CsrGetConsoleOutputCodePage)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
Request->Data.GetConsoleOutputCodePage.CodePage = Console->OutputCodePage;
ConioUnlockConsole(Console);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
CSR_API(CsrSetConsoleOutputCodePage)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
+
if (IsValidCodePage(Request->Data.SetConsoleOutputCodePage.CodePage))
{
Console->OutputCodePage = Request->Data.SetConsoleOutputCodePage.CodePage;
ConioUnlockConsole(Console);
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
}
+
ConioUnlockConsole(Console);
- return Request->Status = STATUS_UNSUCCESSFUL;
+ return STATUS_INVALID_PARAMETER;
}
CSR_API(CsrGetProcessList)
Status = ConioConsoleFromProcessData(ProcessData, &Console);
if (! NT_SUCCESS(Status))
{
- return Request->Status = Status;
+ return Status;
}
DPRINT1("Console_Api Ctrl-C\n");
Request->Header.u1.s1.TotalLength = Length;
Request->Header.u1.s1.DataLength = Length - sizeof(PORT_MESSAGE);
}
- return Request->Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
+}
+
+CSR_API(CsrGenerateCtrlEvent)
+{
+ PCSRSS_CONSOLE Console;
+ PCSRSS_PROCESS_DATA current;
+ PLIST_ENTRY current_entry;
+ DWORD Group;
+ NTSTATUS Status;
+
+ Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
+ Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
+
+ Status = ConioConsoleFromProcessData(ProcessData, &Console);
+ if (! NT_SUCCESS(Status))
+ {
+ return Status;
+ }
+
+ Group = Request->Data.GenerateCtrlEvent.ProcessGroup;
+ Status = STATUS_INVALID_PARAMETER;
+ for (current_entry = Console->ProcessList.Flink;
+ current_entry != &Console->ProcessList;
+ current_entry = current_entry->Flink)
+ {
+ current = CONTAINING_RECORD(current_entry, CSRSS_PROCESS_DATA, ProcessEntry);
+ if (Group == 0 || current->ProcessGroup == Group)
+ {
+ ConioConsoleCtrlEvent(Request->Data.GenerateCtrlEvent.Event, current);
+ Status = STATUS_SUCCESS;
+ }
+ }
+
+ ConioUnlockConsole(Console);
+
+ return Status;
+}
+
+CSR_API(CsrSetScreenBufferSize)
+{
+ NTSTATUS Status;
+ PCSRSS_CONSOLE Console;
+ PCSRSS_SCREEN_BUFFER Buff;
+
+ Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
+ Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
+
+ Status = ConioConsoleFromProcessData(ProcessData, &Console);
+ if (!NT_SUCCESS(Status))
+ {
+ return Status;
+ }
+
+ Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetScreenBufferSize.OutputHandle, &Buff, GENERIC_WRITE);
+ if (!NT_SUCCESS(Status))
+ {
+ ConioUnlockConsole(Console);
+ return Status;
+ }
+
+ Status = ConioResizeBuffer(Console, Buff, Request->Data.SetScreenBufferSize.Size);
+ ConioUnlockScreenBuffer(Buff);
+ ConioUnlockConsole(Console);
+
+ return Status;
}
/* EOF */
projects / reactos.git / blobdiff