Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-09-12 05:43:24 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/dll/win32/kernel32/client/console/readwrite.c
Hermès Bélusca-Maïto 636d4cf0ce [KERNEL32][CONSRV] 
For WriteConsoleOutput API only!! Diagnosed with ApiMonitor from Rohitab.

If one tries to write a too large buffer (>= 80*198 CHAR_INFO cells), the CsrAllocateCaptureBuffer API helper fails, because it uses the non-growable CSR port heap of fixed size 64kB.
Since many applications use the API with large buffers (for example, Far Manager <= 1.70, the Windows XTree app http://textmode.netne.net/Extreme.html , ...) and maybe NTVDM,
Windows (and hence ReactOS for compatibility reasons) allocates a buffer in the process' heap (and not in the CSR port heap via the CSR capture API), so that the big buffer allocation
should work. Then, to be able to access it, CSR needs to call NtReadVirtualMemory for capturing the buffer.

CORE-5006 CORE-6397 CORE-8424 #resolve

svn path=/branches/condrv_restructure/; revision=63841
2014-08-08 17:06:28 +00:00

1784 lines
54 KiB
C
Raw Blame History

/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: dll/win32/kernel32/client/console/readwrite.c
* PURPOSE: Win32 Console Client read-write functions
* PROGRAMMERS: Emanuele Aliberti
* Marty Dill
* Filip Navara (xnavara@volny.cz)
* Thomas Weidenmueller (w3seek@reactos.org)
* Jeffrey Morlan
*/
/* INCLUDES *******************************************************************/
#include <k32.h>
#define NDEBUG
#include <debug.h>
/* See consrv/include/rect.h */
#define ConioRectHeight(Rect) \
(((Rect)->Top) > ((Rect)->Bottom) ? 0 : ((Rect)->Bottom) - ((Rect)->Top) + 1)
#define ConioRectWidth(Rect) \
(((Rect)->Left) > ((Rect)->Right) ? 0 : ((Rect)->Right) - ((Rect)->Left) + 1)
/* PRIVATE FUNCTIONS **********************************************************/
/******************
* Read functions *
******************/
DWORD
WINAPI
GetConsoleInputExeNameW(DWORD nBufferLength, LPWSTR lpBuffer);
static
BOOL
IntReadConsole(IN HANDLE hConsoleInput,
OUT PVOID lpBuffer,
IN DWORD nNumberOfCharsToRead,
OUT LPDWORD lpNumberOfCharsRead,
IN PCONSOLE_READCONSOLE_CONTROL pInputControl OPTIONAL,
IN BOOLEAN bUnicode)
{
BOOL Success;
CONSOLE_API_MESSAGE ApiMessage;
PCONSOLE_READCONSOLE ReadConsoleRequest = &ApiMessage.Data.ReadConsoleRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer = NULL;
ULONG CharSize, SizeBytes;
DPRINT("IntReadConsole\n");
/* Set up the data to send to the Console Server */
ReadConsoleRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
ReadConsoleRequest->InputHandle = hConsoleInput;
ReadConsoleRequest->Unicode = bUnicode;
/*
* Retrieve the current console executable name string and length (always
* in UNICODE format).
* FIXME: Do not use GetConsoleInputExeNameW but use something else...
*/
// 1- Get the exe name length in characters, including NULL character.
ReadConsoleRequest->ExeLength =
(USHORT)GetConsoleInputExeNameW(0, (PWCHAR)ReadConsoleRequest->StaticBuffer);
// 2- Get the exe name (GetConsoleInputExeNameW returns 1 in case of success).
if (GetConsoleInputExeNameW(ReadConsoleRequest->ExeLength,
(PWCHAR)ReadConsoleRequest->StaticBuffer) != 1)
{
// Nothing
ReadConsoleRequest->ExeLength = 0;
}
else
{
// Remove the NULL character, and convert in number of bytes.
ReadConsoleRequest->ExeLength--;
ReadConsoleRequest->ExeLength *= sizeof(WCHAR);
}
/*** For DEBUGGING purposes ***/
{
UNICODE_STRING ExeName;
ExeName.Length = ExeName.MaximumLength = ReadConsoleRequest->ExeLength;
ExeName.Buffer = (PWCHAR)ReadConsoleRequest->StaticBuffer;
DPRINT1("IntReadConsole(ExeName = %wZ)\n", &ExeName);
}
/******************************/
/* Determine the needed size */
CharSize = (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
SizeBytes = nNumberOfCharsToRead * CharSize;
ReadConsoleRequest->CaptureBufferSize =
ReadConsoleRequest->NumBytes = SizeBytes;
/*
* For optimization purposes, Windows (and hence ReactOS, too, for
* compatibility reasons) uses a static buffer if no more than eighty
* bytes are read. Otherwise a new buffer is allocated.
* This behaviour is also expected in the server-side.
*/
if (SizeBytes <= sizeof(ReadConsoleRequest->StaticBuffer))
{
ReadConsoleRequest->Buffer = ReadConsoleRequest->StaticBuffer;
// CaptureBuffer = NULL;
}
else
{
/* Allocate a Capture Buffer */
CaptureBuffer = CsrAllocateCaptureBuffer(1, SizeBytes);
if (CaptureBuffer == NULL)
{
DPRINT1("CsrAllocateCaptureBuffer failed!\n");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
/* Allocate space in the Buffer */
CsrAllocateMessagePointer(CaptureBuffer,
SizeBytes,
(PVOID*)&ReadConsoleRequest->Buffer);
}
ReadConsoleRequest->InitialNumBytes = 0;
ReadConsoleRequest->CtrlWakeupMask = 0;
ReadConsoleRequest->ControlKeyState = 0;
/*
* From MSDN (ReadConsole function), the description
* for pInputControl says:
* "This parameter requires Unicode input by default.
* For ANSI mode, set this parameter to NULL."
*/
_SEH2_TRY
{
if (bUnicode && pInputControl &&
pInputControl->nLength == sizeof(CONSOLE_READCONSOLE_CONTROL))
{
/* Sanity check */
if (pInputControl->nInitialChars <= nNumberOfCharsToRead)
{
ReadConsoleRequest->InitialNumBytes =
pInputControl->nInitialChars * sizeof(WCHAR); // CharSize
if (pInputControl->nInitialChars != 0)
{
/*
* It is possible here to overwrite the static buffer, in case
* the number of bytes to read was smaller than the static buffer.
* In this case, this means we are continuing a pending read,
* and we do not need in fact the executable name that was
* stored in the static buffer because it was first grabbed when
* we started the first read.
*/
RtlCopyMemory(ReadConsoleRequest->Buffer,
lpBuffer,
ReadConsoleRequest->InitialNumBytes);
}
ReadConsoleRequest->CtrlWakeupMask = pInputControl->dwCtrlWakeupMask;
}
else
{
// Status = STATUS_INVALID_PARAMETER;
}
}
else
{
/* We are in a situation where pInputControl has no meaning */
pInputControl = NULL;
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
// HACK
if (CaptureBuffer) CsrFreeCaptureBuffer(CaptureBuffer);
SetLastError(ERROR_INVALID_ACCESS);
_SEH2_YIELD(return FALSE);
}
_SEH2_END;
/* Check for sanity */
/*
if (!NT_SUCCESS(Status) && pInputControl)
{
// Free CaptureBuffer if needed
// Set last error to last status
// Return FALSE
}
*/
/* Call the server */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
CaptureBuffer,
CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepReadConsole),
sizeof(*ReadConsoleRequest));
/* Check for success */
Success = NT_SUCCESS(ApiMessage.Status);
/* Retrieve the results */
if (Success)
{
_SEH2_TRY
{
*lpNumberOfCharsRead = ReadConsoleRequest->NumBytes / CharSize;
if (bUnicode && pInputControl)
pInputControl->dwControlKeyState = ReadConsoleRequest->ControlKeyState;
RtlCopyMemory(lpBuffer,
ReadConsoleRequest->Buffer,
ReadConsoleRequest->NumBytes);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
Success = FALSE;
}
_SEH2_END;
}
else
{
BaseSetLastNTError(ApiMessage.Status);
}
/* Release the capture buffer if needed */
if (CaptureBuffer) CsrFreeCaptureBuffer(CaptureBuffer);
if (Success)
{
/* Yield execution to another thread if Ctrl-C or Ctrl-Break happened */
if (ApiMessage.Status == STATUS_ALERTED /* || ApiMessage.Status == STATUS_CANCELLED */)
{
NtYieldExecution();
SetLastError(ERROR_OPERATION_ABORTED); // STATUS_CANCELLED
}
}
/* Return success status */
return Success;
}
static
BOOL
IntGetConsoleInput(IN HANDLE hConsoleInput,
OUT PINPUT_RECORD lpBuffer,
IN DWORD nLength,
OUT LPDWORD lpNumberOfEventsRead,
IN WORD wFlags,
IN BOOLEAN bUnicode)
{
BOOL Success;
CONSOLE_API_MESSAGE ApiMessage;
PCONSOLE_GETINPUT GetInputRequest = &ApiMessage.Data.GetInputRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer = NULL;
if (!IsConsoleHandle(hConsoleInput))
{
_SEH2_TRY
{
*lpNumberOfEventsRead = 0;
SetLastError(ERROR_INVALID_HANDLE);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
}
_SEH2_END;
return FALSE;
}
DPRINT("IntGetConsoleInput: %lx %p\n", nLength, lpNumberOfEventsRead);
/* Set up the data to send to the Console Server */
GetInputRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
GetInputRequest->InputHandle = hConsoleInput;
GetInputRequest->NumRecords = nLength;
GetInputRequest->Flags = wFlags;
GetInputRequest->Unicode = bUnicode;
/*
* For optimization purposes, Windows (and hence ReactOS, too, for
* compatibility reasons) uses a static buffer if no more than five
* input records are read. Otherwise a new buffer is allocated.
* This behaviour is also expected in the server-side.
*/
if (nLength <= sizeof(GetInputRequest->RecordStaticBuffer)/sizeof(INPUT_RECORD))
{
GetInputRequest->RecordBufPtr = GetInputRequest->RecordStaticBuffer;
// CaptureBuffer = NULL;
}
else
{
ULONG Size = nLength * sizeof(INPUT_RECORD);
/* Allocate a Capture Buffer */
CaptureBuffer = CsrAllocateCaptureBuffer(1, Size);
if (CaptureBuffer == NULL)
{
DPRINT1("CsrAllocateCaptureBuffer failed!\n");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
/* Allocate space in the Buffer */
CsrAllocateMessagePointer(CaptureBuffer,
Size,
(PVOID*)&GetInputRequest->RecordBufPtr);
}
/* Call the server */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
CaptureBuffer,
CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepGetConsoleInput),
sizeof(*GetInputRequest));
/* Check for success */
Success = NT_SUCCESS(ApiMessage.Status);
/* Retrieve the results */
_SEH2_TRY
{
DPRINT("Events read: %lx\n", GetInputRequest->NumRecords);
*lpNumberOfEventsRead = GetInputRequest->NumRecords;
if (Success)
{
RtlCopyMemory(lpBuffer,
GetInputRequest->RecordBufPtr,
GetInputRequest->NumRecords * sizeof(INPUT_RECORD));
}
else
{
BaseSetLastNTError(ApiMessage.Status);
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
Success = FALSE;
}
_SEH2_END;
/* Release the capture buffer if needed */
if (CaptureBuffer) CsrFreeCaptureBuffer(CaptureBuffer);
/* Return success status */
return Success;
}
static
BOOL
IntReadConsoleOutput(IN HANDLE hConsoleOutput,
OUT PCHAR_INFO lpBuffer,
IN COORD dwBufferSize,
IN COORD dwBufferCoord,
IN OUT PSMALL_RECT lpReadRegion,
IN BOOLEAN bUnicode)
{
BOOL Success;
CONSOLE_API_MESSAGE ApiMessage;
PCONSOLE_READOUTPUT ReadOutputRequest = &ApiMessage.Data.ReadOutputRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer = NULL;
SHORT SizeX, SizeY;
ULONG NumCells;
/* Set up the data to send to the Console Server */
ReadOutputRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
ReadOutputRequest->OutputHandle = hConsoleOutput;
ReadOutputRequest->Unicode = bUnicode;
/* Update lpReadRegion */
_SEH2_TRY
{
SizeX = min(dwBufferSize.X - dwBufferCoord.X, ConioRectWidth(lpReadRegion));
SizeY = min(dwBufferSize.Y - dwBufferCoord.Y, ConioRectHeight(lpReadRegion));
if (SizeX <= 0 || SizeY <= 0)
{
SetLastError(ERROR_INVALID_PARAMETER);
_SEH2_YIELD(return FALSE);
}
lpReadRegion->Right = lpReadRegion->Left + SizeX - 1;
lpReadRegion->Bottom = lpReadRegion->Top + SizeY - 1;
ReadOutputRequest->ReadRegion = *lpReadRegion;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
_SEH2_YIELD(return FALSE);
}
_SEH2_END;
NumCells = SizeX * SizeY;
DPRINT("IntReadConsoleOutput: (%d x %d)\n", SizeX, SizeY);
/*
* For optimization purposes, Windows (and hence ReactOS, too, for
* compatibility reasons) uses a static buffer if no more than one
* cell is read. Otherwise a new buffer is allocated.
* This behaviour is also expected in the server-side.
*/
if (NumCells <= 1)
{
ReadOutputRequest->CharInfo = &ReadOutputRequest->StaticBuffer;
// CaptureBuffer = NULL;
}
else
{
ULONG Size = NumCells * sizeof(CHAR_INFO);
/* Allocate a Capture Buffer */
CaptureBuffer = CsrAllocateCaptureBuffer(1, Size);
if (CaptureBuffer == NULL)
{
DPRINT1("CsrAllocateCaptureBuffer failed with size %ld!\n", Size);
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
/* Allocate space in the Buffer */
CsrAllocateMessagePointer(CaptureBuffer,
Size,
(PVOID*)&ReadOutputRequest->CharInfo);
}
/* Call the server */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
CaptureBuffer,
CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepReadConsoleOutput),
sizeof(*ReadOutputRequest));
/* Check for success */
Success = NT_SUCCESS(ApiMessage.Status);
/* Retrieve the results */
_SEH2_TRY
{
*lpReadRegion = ReadOutputRequest->ReadRegion;
if (Success)
{
#if 0
SHORT x, X;
#endif
SHORT y, Y;
/* Copy into the buffer */
SizeX = ReadOutputRequest->ReadRegion.Right -
ReadOutputRequest->ReadRegion.Left + 1;
for (y = 0, Y = ReadOutputRequest->ReadRegion.Top; Y <= ReadOutputRequest->ReadRegion.Bottom; ++y, ++Y)
{
RtlCopyMemory(lpBuffer + (y + dwBufferCoord.Y) * dwBufferSize.X + dwBufferCoord.X,
ReadOutputRequest->CharInfo + y * SizeX,
SizeX * sizeof(CHAR_INFO));
#if 0
for (x = 0, X = ReadOutputRequest->ReadRegion.Left; X <= ReadOutputRequest->ReadRegion.Right; ++x, ++X)
{
*(lpBuffer + (y + dwBufferCoord.Y) * dwBufferSize.X + (x + dwBufferCoord.X)) =
*(ReadOutputRequest->CharInfo + y * SizeX + x);
}
#endif
}
}
else
{
BaseSetLastNTError(ApiMessage.Status);
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
Success = FALSE;
}
_SEH2_END;
/* Release the capture buffer if needed */
if (CaptureBuffer) CsrFreeCaptureBuffer(CaptureBuffer);
/* Return success status */
return Success;
}
static
BOOL
IntReadConsoleOutputCode(IN HANDLE hConsoleOutput,
IN CODE_TYPE CodeType,
OUT PVOID pCode,
IN DWORD nLength,
IN COORD dwReadCoord,
OUT LPDWORD lpNumberOfCodesRead)
{
BOOL Success;
CONSOLE_API_MESSAGE ApiMessage;
PCONSOLE_READOUTPUTCODE ReadOutputCodeRequest = &ApiMessage.Data.ReadOutputCodeRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer = NULL;
ULONG CodeSize, SizeBytes;
DPRINT("IntReadConsoleOutputCode\n");
if ( (CodeType != CODE_ASCII ) &&
(CodeType != CODE_UNICODE ) &&
(CodeType != CODE_ATTRIBUTE) )
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
/* Set up the data to send to the Console Server */
ReadOutputCodeRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
ReadOutputCodeRequest->OutputHandle = hConsoleOutput;
ReadOutputCodeRequest->Coord = dwReadCoord;
ReadOutputCodeRequest->NumCodes = nLength;
/* Determine the needed size */
ReadOutputCodeRequest->CodeType = CodeType;
switch (CodeType)
{
case CODE_ASCII:
CodeSize = RTL_FIELD_SIZE(CODE_ELEMENT, AsciiChar);
break;
case CODE_UNICODE:
CodeSize = RTL_FIELD_SIZE(CODE_ELEMENT, UnicodeChar);
break;
case CODE_ATTRIBUTE:
CodeSize = RTL_FIELD_SIZE(CODE_ELEMENT, Attribute);
break;
}
SizeBytes = nLength * CodeSize;
/*
* For optimization purposes, Windows (and hence ReactOS, too, for
* compatibility reasons) uses a static buffer if no more than eighty
* bytes are read. Otherwise a new buffer is allocated.
* This behaviour is also expected in the server-side.
*/
if (SizeBytes <= sizeof(ReadOutputCodeRequest->CodeStaticBuffer))
{
ReadOutputCodeRequest->pCode = ReadOutputCodeRequest->CodeStaticBuffer;
// CaptureBuffer = NULL;
}
else
{
/* Allocate a Capture Buffer */
CaptureBuffer = CsrAllocateCaptureBuffer(1, SizeBytes);
if (CaptureBuffer == NULL)
{
DPRINT1("CsrAllocateCaptureBuffer failed!\n");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
/* Allocate space in the Buffer */
CsrAllocateMessagePointer(CaptureBuffer,
SizeBytes,
(PVOID*)&ReadOutputCodeRequest->pCode);
}
/* Call the server */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
CaptureBuffer,
CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepReadConsoleOutputString),
sizeof(*ReadOutputCodeRequest));
/* Check for success */
Success = NT_SUCCESS(ApiMessage.Status);
/* Retrieve the results */
_SEH2_TRY
{
*lpNumberOfCodesRead = ReadOutputCodeRequest->NumCodes;
if (Success)
{
RtlCopyMemory(pCode,
ReadOutputCodeRequest->pCode,
ReadOutputCodeRequest->NumCodes * CodeSize);
}
else
{
BaseSetLastNTError(ApiMessage.Status);
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
Success = FALSE;
}
_SEH2_END;
/* Release the capture buffer if needed */
if (CaptureBuffer) CsrFreeCaptureBuffer(CaptureBuffer);
/* Return success status */
return Success;
}
/*******************
* Write functions *
*******************/
static
BOOL
IntWriteConsole(IN HANDLE hConsoleOutput,
IN PVOID lpBuffer,
IN DWORD nNumberOfCharsToWrite,
OUT LPDWORD lpNumberOfCharsWritten,
LPVOID lpReserved,
IN BOOLEAN bUnicode)
{
BOOL Success;
CONSOLE_API_MESSAGE ApiMessage;
PCONSOLE_WRITECONSOLE WriteConsoleRequest = &ApiMessage.Data.WriteConsoleRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer = NULL;
ULONG CharSize, SizeBytes;
DPRINT("IntWriteConsole\n");
/* Set up the data to send to the Console Server */
WriteConsoleRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
WriteConsoleRequest->OutputHandle = hConsoleOutput;
WriteConsoleRequest->Unicode = bUnicode;
/* Those members are unused by the client, on Windows */
WriteConsoleRequest->Reserved1 = 0;
// WriteConsoleRequest->Reserved2 = {0};
/* Determine the needed size */
CharSize = (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
SizeBytes = nNumberOfCharsToWrite * CharSize;
WriteConsoleRequest->NumBytes = SizeBytes;
/*
* For optimization purposes, Windows (and hence ReactOS, too, for
* compatibility reasons) uses a static buffer if no more than eighty
* bytes are written. Otherwise a new buffer is allocated.
* This behaviour is also expected in the server-side.
*/
if (SizeBytes <= sizeof(WriteConsoleRequest->StaticBuffer))
{
WriteConsoleRequest->Buffer = WriteConsoleRequest->StaticBuffer;
// CaptureBuffer = NULL;
WriteConsoleRequest->UsingStaticBuffer = TRUE;
_SEH2_TRY
{
RtlCopyMemory(WriteConsoleRequest->Buffer,
lpBuffer,
SizeBytes);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
_SEH2_YIELD(return FALSE);
}
_SEH2_END;
}
else
{
/* Allocate a Capture Buffer */
CaptureBuffer = CsrAllocateCaptureBuffer(1, SizeBytes);
if (CaptureBuffer == NULL)
{
DPRINT1("CsrAllocateCaptureBuffer failed!\n");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
/* Capture the buffer to write */
CsrCaptureMessageBuffer(CaptureBuffer,
(PVOID)lpBuffer,
SizeBytes,
(PVOID*)&WriteConsoleRequest->Buffer);
WriteConsoleRequest->UsingStaticBuffer = FALSE;
}
/* Call the server */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
CaptureBuffer,
CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepWriteConsole),
sizeof(*WriteConsoleRequest));
/* Check for success */
Success = NT_SUCCESS(ApiMessage.Status);
/* Release the capture buffer if needed */
if (CaptureBuffer) CsrFreeCaptureBuffer(CaptureBuffer);
/* Retrieve the results */
if (Success)
{
_SEH2_TRY
{
*lpNumberOfCharsWritten = WriteConsoleRequest->NumBytes / CharSize;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
Success = FALSE;
}
_SEH2_END;
}
else
{
BaseSetLastNTError(ApiMessage.Status);
}
/* Return success status */
return Success;
}
static
BOOL
IntWriteConsoleInput(IN HANDLE hConsoleInput,
IN PINPUT_RECORD lpBuffer,
IN DWORD nLength,
OUT LPDWORD lpNumberOfEventsWritten,
IN BOOLEAN bUnicode,
IN BOOLEAN bAppendToEnd)
{
BOOL Success;
CONSOLE_API_MESSAGE ApiMessage;
PCONSOLE_WRITEINPUT WriteInputRequest = &ApiMessage.Data.WriteInputRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer = NULL;
DPRINT("IntWriteConsoleInput: %lx %p\n", nLength, lpNumberOfEventsWritten);
/* Set up the data to send to the Console Server */
WriteInputRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
WriteInputRequest->InputHandle = hConsoleInput;
WriteInputRequest->NumRecords = nLength;
WriteInputRequest->Unicode = bUnicode;
WriteInputRequest->AppendToEnd = bAppendToEnd;
/*
* For optimization purposes, Windows (and hence ReactOS, too, for
* compatibility reasons) uses a static buffer if no more than five
* input records are written. Otherwise a new buffer is allocated.
* This behaviour is also expected in the server-side.
*/
if (nLength <= sizeof(WriteInputRequest->RecordStaticBuffer)/sizeof(INPUT_RECORD))
{
WriteInputRequest->RecordBufPtr = WriteInputRequest->RecordStaticBuffer;
// CaptureBuffer = NULL;
_SEH2_TRY
{
RtlCopyMemory(WriteInputRequest->RecordBufPtr,
lpBuffer,
nLength * sizeof(INPUT_RECORD));
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
_SEH2_YIELD(return FALSE);
}
_SEH2_END;
}
else
{
ULONG Size = nLength * sizeof(INPUT_RECORD);
/* Allocate a Capture Buffer */
CaptureBuffer = CsrAllocateCaptureBuffer(1, Size);
if (CaptureBuffer == NULL)
{
DPRINT1("CsrAllocateCaptureBuffer failed!\n");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
/* Capture the user buffer */
CsrCaptureMessageBuffer(CaptureBuffer,
lpBuffer,
Size,
(PVOID*)&WriteInputRequest->RecordBufPtr);
}
/* Call the server */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
CaptureBuffer,
CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepWriteConsoleInput),
sizeof(*WriteInputRequest));
/* Check for success */
Success = NT_SUCCESS(ApiMessage.Status);
/* Release the capture buffer if needed */
if (CaptureBuffer) CsrFreeCaptureBuffer(CaptureBuffer);
/* Retrieve the results */
_SEH2_TRY
{
DPRINT("Events written: %lx\n", WriteInputRequest->NumRecords);
*lpNumberOfEventsWritten = WriteInputRequest->NumRecords;
if (!Success)
BaseSetLastNTError(ApiMessage.Status);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
Success = FALSE;
}
_SEH2_END;
/* Return success status */
return Success;
}
static
BOOL
IntWriteConsoleOutput(IN HANDLE hConsoleOutput,
IN CONST CHAR_INFO *lpBuffer,
IN COORD dwBufferSize,
IN COORD dwBufferCoord,
IN OUT PSMALL_RECT lpWriteRegion,
IN BOOLEAN bUnicode)
{
BOOL Success;
CONSOLE_API_MESSAGE ApiMessage;
PCONSOLE_WRITEOUTPUT WriteOutputRequest = &ApiMessage.Data.WriteOutputRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer = NULL;
SHORT SizeX, SizeY;
ULONG NumCells;
/* Set up the data to send to the Console Server */
WriteOutputRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
WriteOutputRequest->OutputHandle = hConsoleOutput;
WriteOutputRequest->Unicode = bUnicode;
/* Update lpWriteRegion */
_SEH2_TRY
{
SizeX = min(dwBufferSize.X - dwBufferCoord.X, ConioRectWidth(lpWriteRegion));
SizeY = min(dwBufferSize.Y - dwBufferCoord.Y, ConioRectHeight(lpWriteRegion));
if (SizeX <= 0 || SizeY <= 0)
{
SetLastError(ERROR_INVALID_PARAMETER);
_SEH2_YIELD(return FALSE);
}
lpWriteRegion->Right = lpWriteRegion->Left + SizeX - 1;
lpWriteRegion->Bottom = lpWriteRegion->Top + SizeY - 1;
WriteOutputRequest->WriteRegion = *lpWriteRegion;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
_SEH2_YIELD(return FALSE);
}
_SEH2_END;
NumCells = SizeX * SizeY;
DPRINT("IntWriteConsoleOutput: (%d x %d)\n", SizeX, SizeY);
/*
* For optimization purposes, Windows (and hence ReactOS, too, for
* compatibility reasons) uses a static buffer if no more than one
* cell is written. Otherwise a new buffer is allocated.
* This behaviour is also expected in the server-side.
*/
if (NumCells <= 1)
{
WriteOutputRequest->CharInfo = &WriteOutputRequest->StaticBuffer;
// CaptureBuffer = NULL;
WriteOutputRequest->UseVirtualMemory = FALSE;
}
else
{
ULONG Size = NumCells * sizeof(CHAR_INFO);
/* Allocate a Capture Buffer */
CaptureBuffer = CsrAllocateCaptureBuffer(1, Size);
if (CaptureBuffer)
{
/* Allocate space in the Buffer */
CsrAllocateMessagePointer(CaptureBuffer,
Size,
(PVOID*)&WriteOutputRequest->CharInfo);
WriteOutputRequest->UseVirtualMemory = FALSE;
}
else
{
/*
* CsrAllocateCaptureBuffer failed because we tried to allocate
* a too large (>= 64 kB, size of the CSR heap) data buffer.
* To circumvent this, Windows uses a trick (that we reproduce for
* compatibility reasons): we allocate a heap buffer in the process'
* memory, and CSR will read it via NtReadVirtualMemory.
*/
DPRINT1("CsrAllocateCaptureBuffer failed with size %ld, let's use local heap buffer...\n", Size);
WriteOutputRequest->CharInfo = RtlAllocateHeap(RtlGetProcessHeap(), 0, Size);
WriteOutputRequest->UseVirtualMemory = TRUE;
/* Bail out if we still cannot allocate memory */
if (WriteOutputRequest->CharInfo == NULL)
{
DPRINT1("Failed to allocate heap buffer with size %ld!\n", Size);
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
}
}
/* Capture the user buffer contents */
_SEH2_TRY
{
#if 0
SHORT x, X;
#endif
SHORT y, Y;
/* Copy into the buffer */
SizeX = WriteOutputRequest->WriteRegion.Right -
WriteOutputRequest->WriteRegion.Left + 1;
for (y = 0, Y = WriteOutputRequest->WriteRegion.Top; Y <= WriteOutputRequest->WriteRegion.Bottom; ++y, ++Y)
{
RtlCopyMemory(WriteOutputRequest->CharInfo + y * SizeX,
lpBuffer + (y + dwBufferCoord.Y) * dwBufferSize.X + dwBufferCoord.X,
SizeX * sizeof(CHAR_INFO));
#if 0
for (x = 0, X = WriteOutputRequest->WriteRegion.Left; X <= WriteOutputRequest->WriteRegion.Right; ++x, ++X)
{
*(WriteOutputRequest->CharInfo + y * SizeX + x) =
*(lpBuffer + (y + dwBufferCoord.Y) * dwBufferSize.X + (x + dwBufferCoord.X));
}
#endif
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
_SEH2_YIELD(return FALSE);
}
_SEH2_END;
/* Call the server */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
CaptureBuffer,
CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepWriteConsoleOutput),
sizeof(*WriteOutputRequest));
/* Check for success */
Success = NT_SUCCESS(ApiMessage.Status);
/* Release the capture buffer if needed */
if (CaptureBuffer)
{
CsrFreeCaptureBuffer(CaptureBuffer);
}
else
{
/* If we used a heap buffer, free it */
if (WriteOutputRequest->UseVirtualMemory)
RtlFreeHeap(RtlGetProcessHeap(), 0, WriteOutputRequest->CharInfo);
}
/* Retrieve the results */
_SEH2_TRY
{
*lpWriteRegion = WriteOutputRequest->WriteRegion;
if (!Success)
BaseSetLastNTError(ApiMessage.Status);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
Success = FALSE;
}
_SEH2_END;
/* Return success status */
return Success;
}
static
BOOL
IntWriteConsoleOutputCode(IN HANDLE hConsoleOutput,
IN CODE_TYPE CodeType,
IN CONST VOID *pCode,
IN DWORD nLength,
IN COORD dwWriteCoord,
OUT LPDWORD lpNumberOfCodesWritten)
{
BOOL Success;
CONSOLE_API_MESSAGE ApiMessage;
PCONSOLE_WRITEOUTPUTCODE WriteOutputCodeRequest = &ApiMessage.Data.WriteOutputCodeRequest;
PCSR_CAPTURE_BUFFER CaptureBuffer = NULL;
ULONG CodeSize, SizeBytes;
if ( (CodeType != CODE_ASCII ) &&
(CodeType != CODE_UNICODE ) &&
(CodeType != CODE_ATTRIBUTE) )
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
DPRINT("IntWriteConsoleOutputCode\n");
/* Set up the data to send to the Console Server */
WriteOutputCodeRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
WriteOutputCodeRequest->OutputHandle = hConsoleOutput;
WriteOutputCodeRequest->Coord = dwWriteCoord;
WriteOutputCodeRequest->NumCodes = nLength;
/* Determine the needed size */
WriteOutputCodeRequest->CodeType = CodeType;
switch (CodeType)
{
case CODE_ASCII:
CodeSize = RTL_FIELD_SIZE(CODE_ELEMENT, AsciiChar);
break;
case CODE_UNICODE:
CodeSize = RTL_FIELD_SIZE(CODE_ELEMENT, UnicodeChar);
break;
case CODE_ATTRIBUTE:
CodeSize = RTL_FIELD_SIZE(CODE_ELEMENT, Attribute);
break;
}
SizeBytes = nLength * CodeSize;
/*
* For optimization purposes, Windows (and hence ReactOS, too, for
* compatibility reasons) uses a static buffer if no more than eighty
* bytes are written. Otherwise a new buffer is allocated.
* This behaviour is also expected in the server-side.
*/
if (SizeBytes <= sizeof(WriteOutputCodeRequest->CodeStaticBuffer))
{
WriteOutputCodeRequest->pCode = WriteOutputCodeRequest->CodeStaticBuffer;
// CaptureBuffer = NULL;
_SEH2_TRY
{
RtlCopyMemory(WriteOutputCodeRequest->pCode,
pCode,
SizeBytes);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
_SEH2_YIELD(return FALSE);
}
_SEH2_END;
}
else
{
/* Allocate a Capture Buffer */
CaptureBuffer = CsrAllocateCaptureBuffer(1, SizeBytes);
if (CaptureBuffer == NULL)
{
DPRINT1("CsrAllocateCaptureBuffer failed!\n");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
/* Capture the buffer to write */
CsrCaptureMessageBuffer(CaptureBuffer,
(PVOID)pCode,
SizeBytes,
(PVOID*)&WriteOutputCodeRequest->pCode);
}
/* Call the server */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
CaptureBuffer,
CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepWriteConsoleOutputString),
sizeof(*WriteOutputCodeRequest));
/* Check for success */
Success = NT_SUCCESS(ApiMessage.Status);
/* Release the capture buffer if needed */
if (CaptureBuffer) CsrFreeCaptureBuffer(CaptureBuffer);
/* Retrieve the results */
_SEH2_TRY
{
*lpNumberOfCodesWritten = WriteOutputCodeRequest->NumCodes;
if (!Success)
BaseSetLastNTError(ApiMessage.Status);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
Success = FALSE;
}
_SEH2_END;
/* Return success status */
return Success;
}
static
BOOL
IntFillConsoleOutputCode(IN HANDLE hConsoleOutput,
IN CODE_TYPE CodeType,
IN CODE_ELEMENT Code,
IN DWORD nLength,
IN COORD dwWriteCoord,
OUT LPDWORD lpNumberOfCodesWritten)
{
BOOL Success;
CONSOLE_API_MESSAGE ApiMessage;
PCONSOLE_FILLOUTPUTCODE FillOutputRequest = &ApiMessage.Data.FillOutputRequest;
DPRINT("IntFillConsoleOutputCode\n");
if ( (CodeType != CODE_ASCII ) &&
(CodeType != CODE_UNICODE ) &&
(CodeType != CODE_ATTRIBUTE) )
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
/* Set up the data to send to the Console Server */
FillOutputRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
FillOutputRequest->OutputHandle = hConsoleOutput;
FillOutputRequest->WriteCoord = dwWriteCoord;
FillOutputRequest->CodeType = CodeType;
FillOutputRequest->Code = Code;
FillOutputRequest->NumCodes = nLength;
/* Call the server */
CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
NULL,
CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepFillConsoleOutput),
sizeof(*FillOutputRequest));
/* Check for success */
Success = NT_SUCCESS(ApiMessage.Status);
/* Retrieve the results */
_SEH2_TRY
{
*lpNumberOfCodesWritten = FillOutputRequest->NumCodes;
if (!Success)
BaseSetLastNTError(ApiMessage.Status);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(ERROR_INVALID_ACCESS);
Success = FALSE;
}
_SEH2_END;
/* Return success status */
return Success;
}
/* FUNCTIONS ******************************************************************/
/******************
* Read functions *
******************/
/*--------------------------------------------------------------
* ReadConsoleW
*
* @implemented
*/
BOOL
WINAPI
ReadConsoleW(IN HANDLE hConsoleInput,
OUT LPVOID lpBuffer,
IN DWORD nNumberOfCharsToRead,
OUT LPDWORD lpNumberOfCharsRead,
IN PCONSOLE_READCONSOLE_CONTROL pInputControl OPTIONAL)
{
return IntReadConsole(hConsoleInput,
lpBuffer,
nNumberOfCharsToRead,
lpNumberOfCharsRead,
pInputControl,
TRUE);
}
/*--------------------------------------------------------------
* ReadConsoleA
*
* @implemented
*/
BOOL
WINAPI
ReadConsoleA(IN HANDLE hConsoleInput,
OUT LPVOID lpBuffer,
IN DWORD nNumberOfCharsToRead,
OUT LPDWORD lpNumberOfCharsRead,
IN PCONSOLE_READCONSOLE_CONTROL pInputControl OPTIONAL)
{
return IntReadConsole(hConsoleInput,
lpBuffer,
nNumberOfCharsToRead,
lpNumberOfCharsRead,
NULL,
FALSE);
}
/*--------------------------------------------------------------
* PeekConsoleInputW
*
* @implemented
*/
BOOL
WINAPI
PeekConsoleInputW(IN HANDLE hConsoleInput,
OUT PINPUT_RECORD lpBuffer,
IN DWORD nLength,
OUT LPDWORD lpNumberOfEventsRead)
{
return IntGetConsoleInput(hConsoleInput,
lpBuffer,
nLength,
lpNumberOfEventsRead,
CONSOLE_READ_KEEPEVENT | CONSOLE_READ_CONTINUE,
TRUE);
}
/*--------------------------------------------------------------
* PeekConsoleInputA
*
* @implemented
*/
BOOL
WINAPI
PeekConsoleInputA(IN HANDLE hConsoleInput,
OUT PINPUT_RECORD lpBuffer,
IN DWORD nLength,
OUT LPDWORD lpNumberOfEventsRead)
{
return IntGetConsoleInput(hConsoleInput,
lpBuffer,
nLength,
lpNumberOfEventsRead,
CONSOLE_READ_KEEPEVENT | CONSOLE_READ_CONTINUE,
FALSE);
}
/*--------------------------------------------------------------
* ReadConsoleInputW
*
* @implemented
*/
BOOL
WINAPI
ReadConsoleInputW(IN HANDLE hConsoleInput,
OUT PINPUT_RECORD lpBuffer,
IN DWORD nLength,
OUT LPDWORD lpNumberOfEventsRead)
{
return IntGetConsoleInput(hConsoleInput,
lpBuffer,
nLength,
lpNumberOfEventsRead,
0,
TRUE);
}
/*--------------------------------------------------------------
* ReadConsoleInputA
*
* @implemented
*/
BOOL
WINAPI
ReadConsoleInputA(IN HANDLE hConsoleInput,
OUT PINPUT_RECORD lpBuffer,
IN DWORD nLength,
OUT LPDWORD lpNumberOfEventsRead)
{
return IntGetConsoleInput(hConsoleInput,
lpBuffer,
nLength,
lpNumberOfEventsRead,
0,
FALSE);
}
/*--------------------------------------------------------------
* ReadConsoleInputExW
*
* @implemented
*/
BOOL
WINAPI
ReadConsoleInputExW(IN HANDLE hConsoleInput,
OUT PINPUT_RECORD lpBuffer,
IN DWORD nLength,
OUT LPDWORD lpNumberOfEventsRead,
IN WORD wFlags)
{
return IntGetConsoleInput(hConsoleInput,
lpBuffer,
nLength,
lpNumberOfEventsRead,
wFlags,
TRUE);
}
/*--------------------------------------------------------------
* ReadConsoleInputExA
*
* @implemented
*/
BOOL
WINAPI
ReadConsoleInputExA(IN HANDLE hConsoleInput,
OUT PINPUT_RECORD lpBuffer,
IN DWORD nLength,
OUT LPDWORD lpNumberOfEventsRead,
IN WORD wFlags)
{
return IntGetConsoleInput(hConsoleInput,
lpBuffer,
nLength,
lpNumberOfEventsRead,
wFlags,
FALSE);
}
/*--------------------------------------------------------------
* ReadConsoleOutputW
*
* @implemented
*/
BOOL
WINAPI
ReadConsoleOutputW(IN HANDLE hConsoleOutput,
OUT PCHAR_INFO lpBuffer,
IN COORD dwBufferSize,
IN COORD dwBufferCoord,
IN OUT PSMALL_RECT lpReadRegion)
{
return IntReadConsoleOutput(hConsoleOutput,
lpBuffer,
dwBufferSize,
dwBufferCoord,
lpReadRegion,
TRUE);
}
/*--------------------------------------------------------------
* ReadConsoleOutputA
*
* @implemented
*/
BOOL
WINAPI
ReadConsoleOutputA(IN HANDLE hConsoleOutput,
OUT PCHAR_INFO lpBuffer,
IN COORD dwBufferSize,
IN COORD dwBufferCoord,
IN OUT PSMALL_RECT lpReadRegion)
{
return IntReadConsoleOutput(hConsoleOutput,
lpBuffer,
dwBufferSize,
dwBufferCoord,
lpReadRegion,
FALSE);
}
/*--------------------------------------------------------------
* ReadConsoleOutputCharacterW
*
* @implemented
*/
BOOL
WINAPI
ReadConsoleOutputCharacterW(IN HANDLE hConsoleOutput,
OUT LPWSTR lpCharacter,
IN DWORD nLength,
IN COORD dwReadCoord,
OUT LPDWORD lpNumberOfCharsRead)
{
return IntReadConsoleOutputCode(hConsoleOutput,
CODE_UNICODE,
lpCharacter,
nLength,
dwReadCoord,
lpNumberOfCharsRead);
}
/*--------------------------------------------------------------
* ReadConsoleOutputCharacterA
*
* @implemented
*/
BOOL
WINAPI
ReadConsoleOutputCharacterA(IN HANDLE hConsoleOutput,
OUT LPSTR lpCharacter,
IN DWORD nLength,
IN COORD dwReadCoord,
OUT LPDWORD lpNumberOfCharsRead)
{
return IntReadConsoleOutputCode(hConsoleOutput,
CODE_ASCII,
lpCharacter,
nLength,
dwReadCoord,
lpNumberOfCharsRead);
}
/*--------------------------------------------------------------
* ReadConsoleOutputAttribute
*
* @implemented
*/
BOOL
WINAPI
ReadConsoleOutputAttribute(IN HANDLE hConsoleOutput,
OUT LPWORD lpAttribute,
IN DWORD nLength,
IN COORD dwReadCoord,
OUT LPDWORD lpNumberOfAttrsRead)
{
return IntReadConsoleOutputCode(hConsoleOutput,
CODE_ATTRIBUTE,
lpAttribute,
nLength,
dwReadCoord,
lpNumberOfAttrsRead);
}
/*******************
* Write functions *
*******************/
/*--------------------------------------------------------------
* WriteConsoleW
*
* @implemented
*/
BOOL
WINAPI
WriteConsoleW(IN HANDLE hConsoleOutput,
IN CONST VOID *lpBuffer,
IN DWORD nNumberOfCharsToWrite,
OUT LPDWORD lpNumberOfCharsWritten,
LPVOID lpReserved)
{
return IntWriteConsole(hConsoleOutput,
(PVOID)lpBuffer,
nNumberOfCharsToWrite,
lpNumberOfCharsWritten,
lpReserved,
TRUE);
}
/*--------------------------------------------------------------
* WriteConsoleA
*
* @implemented
*/
BOOL
WINAPI
WriteConsoleA(IN HANDLE hConsoleOutput,
IN CONST VOID *lpBuffer,
IN DWORD nNumberOfCharsToWrite,
OUT LPDWORD lpNumberOfCharsWritten,
LPVOID lpReserved)
{
return IntWriteConsole(hConsoleOutput,
(PVOID)lpBuffer,
nNumberOfCharsToWrite,
lpNumberOfCharsWritten,
lpReserved,
FALSE);
}
/*--------------------------------------------------------------
* WriteConsoleInputW
*
* @implemented
*/
BOOL
WINAPI
WriteConsoleInputW(IN HANDLE hConsoleInput,
IN CONST INPUT_RECORD *lpBuffer,
IN DWORD nLength,
OUT LPDWORD lpNumberOfEventsWritten)
{
return IntWriteConsoleInput(hConsoleInput,
(PINPUT_RECORD)lpBuffer,
nLength,
lpNumberOfEventsWritten,
TRUE,
TRUE);
}
/*--------------------------------------------------------------
* WriteConsoleInputA
*
* @implemented
*/
BOOL
WINAPI
WriteConsoleInputA(IN HANDLE hConsoleInput,
IN CONST INPUT_RECORD *lpBuffer,
IN DWORD nLength,
OUT LPDWORD lpNumberOfEventsWritten)
{
return IntWriteConsoleInput(hConsoleInput,
(PINPUT_RECORD)lpBuffer,
nLength,
lpNumberOfEventsWritten,
FALSE,
TRUE);
}
/*--------------------------------------------------------------
* WriteConsoleInputVDMW
*
* @implemented
*/
BOOL
WINAPI
WriteConsoleInputVDMW(IN HANDLE hConsoleInput,
IN CONST INPUT_RECORD *lpBuffer,
IN DWORD nLength,
OUT LPDWORD lpNumberOfEventsWritten)
{
return IntWriteConsoleInput(hConsoleInput,
(PINPUT_RECORD)lpBuffer,
nLength,
lpNumberOfEventsWritten,
TRUE,
FALSE);
}
/*--------------------------------------------------------------
* WriteConsoleInputVDMA
*
* @implemented
*/
BOOL
WINAPI
WriteConsoleInputVDMA(IN HANDLE hConsoleInput,
IN CONST INPUT_RECORD *lpBuffer,
IN DWORD nLength,
OUT LPDWORD lpNumberOfEventsWritten)
{
return IntWriteConsoleInput(hConsoleInput,
(PINPUT_RECORD)lpBuffer,
nLength,
lpNumberOfEventsWritten,
FALSE,
FALSE);
}
/*--------------------------------------------------------------
* WriteConsoleOutputW
*
* @implemented
*/
BOOL
WINAPI
WriteConsoleOutputW(IN HANDLE hConsoleOutput,
IN CONST CHAR_INFO *lpBuffer,
IN COORD dwBufferSize,
IN COORD dwBufferCoord,
IN OUT PSMALL_RECT lpWriteRegion)
{
return IntWriteConsoleOutput(hConsoleOutput,
lpBuffer,
dwBufferSize,
dwBufferCoord,
lpWriteRegion,
TRUE);
}
/*--------------------------------------------------------------
* WriteConsoleOutputA
*
* @implemented
*/
BOOL
WINAPI
WriteConsoleOutputA(IN HANDLE hConsoleOutput,
IN CONST CHAR_INFO *lpBuffer,
IN COORD dwBufferSize,
IN COORD dwBufferCoord,
IN OUT PSMALL_RECT lpWriteRegion)
{
return IntWriteConsoleOutput(hConsoleOutput,
lpBuffer,
dwBufferSize,
dwBufferCoord,
lpWriteRegion,
FALSE);
}
/*--------------------------------------------------------------
* WriteConsoleOutputCharacterW
*
* @implemented
*/
BOOL
WINAPI
WriteConsoleOutputCharacterW(IN HANDLE hConsoleOutput,
IN LPCWSTR lpCharacter,
IN DWORD nLength,
IN COORD dwWriteCoord,
OUT LPDWORD lpNumberOfCharsWritten)
{
return IntWriteConsoleOutputCode(hConsoleOutput,
CODE_UNICODE,
lpCharacter,
nLength,
dwWriteCoord,
lpNumberOfCharsWritten);
}
/*--------------------------------------------------------------
* WriteConsoleOutputCharacterA
*
* @implemented
*/
BOOL
WINAPI
WriteConsoleOutputCharacterA(IN HANDLE hConsoleOutput,
IN LPCSTR lpCharacter,
IN DWORD nLength,
IN COORD dwWriteCoord,
OUT LPDWORD lpNumberOfCharsWritten)
{
return IntWriteConsoleOutputCode(hConsoleOutput,
CODE_ASCII,
lpCharacter,
nLength,
dwWriteCoord,
lpNumberOfCharsWritten);
}
/*--------------------------------------------------------------
* WriteConsoleOutputAttribute
*
* @implemented
*/
BOOL
WINAPI
WriteConsoleOutputAttribute(IN HANDLE hConsoleOutput,
IN CONST WORD *lpAttribute,
IN DWORD nLength,
IN COORD dwWriteCoord,
OUT LPDWORD lpNumberOfAttrsWritten)
{
return IntWriteConsoleOutputCode(hConsoleOutput,
CODE_ATTRIBUTE,
lpAttribute,
nLength,
dwWriteCoord,
lpNumberOfAttrsWritten);
}
/*--------------------------------------------------------------
* FillConsoleOutputCharacterW
*
* @implemented
*/
BOOL
WINAPI
FillConsoleOutputCharacterW(IN HANDLE hConsoleOutput,
IN WCHAR cCharacter,
IN DWORD nLength,
IN COORD dwWriteCoord,
OUT LPDWORD lpNumberOfCharsWritten)
{
CODE_ELEMENT Code;
Code.UnicodeChar = cCharacter;
return IntFillConsoleOutputCode(hConsoleOutput,
CODE_UNICODE,
Code,
nLength,
dwWriteCoord,
lpNumberOfCharsWritten);
}
/*--------------------------------------------------------------
* FillConsoleOutputCharacterA
*
* @implemented
*/
BOOL
WINAPI
FillConsoleOutputCharacterA(IN HANDLE hConsoleOutput,
IN CHAR cCharacter,
IN DWORD nLength,
IN COORD dwWriteCoord,
LPDWORD lpNumberOfCharsWritten)
{
CODE_ELEMENT Code;
Code.AsciiChar = cCharacter;
return IntFillConsoleOutputCode(hConsoleOutput,
CODE_ASCII,
Code,
nLength,
dwWriteCoord,
lpNumberOfCharsWritten);
}
/*--------------------------------------------------------------
* FillConsoleOutputAttribute
*
* @implemented
*/
BOOL
WINAPI
FillConsoleOutputAttribute(IN HANDLE hConsoleOutput,
IN WORD wAttribute,
IN DWORD nLength,
IN COORD dwWriteCoord,
OUT LPDWORD lpNumberOfAttrsWritten)
{
CODE_ELEMENT Code;
Code.Attribute = wAttribute;
return IntFillConsoleOutputCode(hConsoleOutput,
CODE_ATTRIBUTE,
Code,
nLength,
dwWriteCoord,
lpNumberOfAttrsWritten);
}
/* EOF */
Reference in a new issue View git blame Copy permalink