1218 lines
50 KiB
C++
1218 lines
50 KiB
C++
// Copyright (c) Microsoft Corporation.
|
|
// Licensed under the MIT license.
|
|
|
|
#include "precomp.h"
|
|
|
|
#include "directio.h"
|
|
|
|
#include "_output.h"
|
|
#include "output.h"
|
|
#include "input.h"
|
|
#include "dbcs.h"
|
|
#include "handle.h"
|
|
#include "misc.h"
|
|
#include "readDataDirect.hpp"
|
|
#include "ApiRoutines.h"
|
|
|
|
#include "../types/inc/convert.hpp"
|
|
#include "../types/inc/GlyphWidth.hpp"
|
|
#include "../types/inc/viewport.hpp"
|
|
|
|
#include "../interactivity/inc/ServiceLocator.hpp"
|
|
|
|
#pragma hdrstop
|
|
|
|
using namespace Microsoft::Console::Types;
|
|
using Microsoft::Console::Interactivity::ServiceLocator;
|
|
|
|
class CONSOLE_INFORMATION;
|
|
|
|
#define UNICODE_DBCS_PADDING 0xffff
|
|
|
|
// Routine Description:
|
|
// - converts non-unicode InputEvents to unicode InputEvents
|
|
// Arguments:
|
|
// inEvents - InputEvents to convert
|
|
// partialEvent - on output, will contain a partial dbcs byte char
|
|
// data if the last event in inEvents is a dbcs lead byte
|
|
// Return Value:
|
|
// - inEvents will contain unicode InputEvents
|
|
// - partialEvent may contain a partial dbcs KeyEvent
|
|
void EventsToUnicode(_Inout_ std::deque<std::unique_ptr<IInputEvent>>& inEvents,
|
|
_Out_ std::unique_ptr<IInputEvent>& partialEvent)
|
|
{
|
|
const CONSOLE_INFORMATION& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
|
|
std::deque<std::unique_ptr<IInputEvent>> outEvents;
|
|
|
|
while (!inEvents.empty())
|
|
{
|
|
std::unique_ptr<IInputEvent> currentEvent = std::move(inEvents.front());
|
|
inEvents.pop_front();
|
|
|
|
if (currentEvent->EventType() != InputEventType::KeyEvent)
|
|
{
|
|
outEvents.push_back(std::move(currentEvent));
|
|
}
|
|
else
|
|
{
|
|
const KeyEvent* const keyEvent = static_cast<const KeyEvent* const>(currentEvent.get());
|
|
|
|
std::wstring outWChar;
|
|
HRESULT hr = S_OK;
|
|
|
|
// convert char data to unicode
|
|
if (IsDBCSLeadByteConsole(static_cast<char>(keyEvent->GetCharData()), &gci.CPInfo))
|
|
{
|
|
if (inEvents.empty())
|
|
{
|
|
// we ran out of data and have a partial byte leftover
|
|
partialEvent = std::move(currentEvent);
|
|
break;
|
|
}
|
|
|
|
// get the 2nd byte and convert to unicode
|
|
const KeyEvent* const keyEventEndByte = static_cast<const KeyEvent* const>(inEvents.front().get());
|
|
inEvents.pop_front();
|
|
|
|
char inBytes[] = {
|
|
static_cast<char>(keyEvent->GetCharData()),
|
|
static_cast<char>(keyEventEndByte->GetCharData())
|
|
};
|
|
try
|
|
{
|
|
outWChar = ConvertToW(gci.CP, { inBytes, ARRAYSIZE(inBytes) });
|
|
}
|
|
catch (...)
|
|
{
|
|
hr = wil::ResultFromCaughtException();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
char inBytes[] = {
|
|
static_cast<char>(keyEvent->GetCharData())
|
|
};
|
|
try
|
|
{
|
|
outWChar = ConvertToW(gci.CP, { inBytes, ARRAYSIZE(inBytes) });
|
|
}
|
|
catch (...)
|
|
{
|
|
hr = wil::ResultFromCaughtException();
|
|
}
|
|
}
|
|
|
|
// push unicode key events back out
|
|
if (SUCCEEDED(hr) && outWChar.size() > 0)
|
|
{
|
|
KeyEvent unicodeKeyEvent = *keyEvent;
|
|
for (const auto wch : outWChar)
|
|
{
|
|
try
|
|
{
|
|
unicodeKeyEvent.SetCharData(wch);
|
|
outEvents.push_back(std::make_unique<KeyEvent>(unicodeKeyEvent));
|
|
}
|
|
catch (...)
|
|
{
|
|
LOG_HR(wil::ResultFromCaughtException());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
inEvents.swap(outEvents);
|
|
return;
|
|
}
|
|
|
|
// Routine Description:
|
|
// - This routine reads or peeks input events. In both cases, the events
|
|
// are copied to the user's buffer. In the read case they are removed
|
|
// from the input buffer and in the peek case they are not.
|
|
// Arguments:
|
|
// - pInputBuffer - The input buffer to take records from to return to the client
|
|
// - outEvents - The storage location to fill with input events
|
|
// - eventReadCount - The number of events to read
|
|
// - pInputReadHandleData - A structure that will help us maintain
|
|
// some input context across various calls on the same input
|
|
// handle. Primarily used to restore the "other piece" of partially
|
|
// returned strings (because client buffer wasn't big enough) on the
|
|
// next call.
|
|
// - IsUnicode - Whether to operate on Unicode characters or convert
|
|
// on the current Input Codepage.
|
|
// - IsPeek - If this is a peek operation (a.k.a. do not remove
|
|
// characters from the input buffer while copying to client buffer.)
|
|
// - ppWaiter - If we have to wait (not enough data to fill client
|
|
// buffer), this contains context that will allow the server to
|
|
// restore this call later.
|
|
// Return Value:
|
|
// - STATUS_SUCCESS - If data was found and ready for return to the client.
|
|
// - CONSOLE_STATUS_WAIT - If we didn't have enough data or needed to
|
|
// block, this will be returned along with context in *ppWaiter.
|
|
// - Or an out of memory/math/string error message in NTSTATUS format.
|
|
[[nodiscard]] static NTSTATUS _DoGetConsoleInput(InputBuffer& inputBuffer,
|
|
std::deque<std::unique_ptr<IInputEvent>>& outEvents,
|
|
const size_t eventReadCount,
|
|
INPUT_READ_HANDLE_DATA& readHandleState,
|
|
const bool IsUnicode,
|
|
const bool IsPeek,
|
|
std::unique_ptr<IWaitRoutine>& waiter) noexcept
|
|
{
|
|
try
|
|
{
|
|
waiter.reset();
|
|
|
|
if (eventReadCount == 0)
|
|
{
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
LockConsole();
|
|
auto Unlock = wil::scope_exit([&] { UnlockConsole(); });
|
|
|
|
std::deque<std::unique_ptr<IInputEvent>> partialEvents;
|
|
if (!IsUnicode)
|
|
{
|
|
if (inputBuffer.IsReadPartialByteSequenceAvailable())
|
|
{
|
|
partialEvents.push_back(inputBuffer.FetchReadPartialByteSequence(IsPeek));
|
|
}
|
|
}
|
|
|
|
size_t amountToRead;
|
|
if (FAILED(SizeTSub(eventReadCount, partialEvents.size(), &amountToRead)))
|
|
{
|
|
return STATUS_INTEGER_OVERFLOW;
|
|
}
|
|
std::deque<std::unique_ptr<IInputEvent>> readEvents;
|
|
NTSTATUS Status = inputBuffer.Read(readEvents,
|
|
amountToRead,
|
|
IsPeek,
|
|
true,
|
|
IsUnicode,
|
|
false);
|
|
|
|
if (CONSOLE_STATUS_WAIT == Status)
|
|
{
|
|
FAIL_FAST_IF(!(readEvents.empty()));
|
|
// If we're told to wait until later, move all of our context
|
|
// to the read data object and send it back up to the server.
|
|
waiter = std::make_unique<DirectReadData>(&inputBuffer,
|
|
&readHandleState,
|
|
eventReadCount,
|
|
std::move(partialEvents));
|
|
}
|
|
else if (NT_SUCCESS(Status))
|
|
{
|
|
// split key events to oem chars if necessary
|
|
if (!IsUnicode)
|
|
{
|
|
try
|
|
{
|
|
SplitToOem(readEvents);
|
|
}
|
|
CATCH_LOG();
|
|
}
|
|
|
|
// combine partial and readEvents
|
|
while (!partialEvents.empty())
|
|
{
|
|
readEvents.push_front(std::move(partialEvents.back()));
|
|
partialEvents.pop_back();
|
|
}
|
|
|
|
// move events over
|
|
for (size_t i = 0; i < eventReadCount; ++i)
|
|
{
|
|
if (readEvents.empty())
|
|
{
|
|
break;
|
|
}
|
|
outEvents.push_back(std::move(readEvents.front()));
|
|
readEvents.pop_front();
|
|
}
|
|
|
|
// store partial event if necessary
|
|
if (!readEvents.empty())
|
|
{
|
|
inputBuffer.StoreReadPartialByteSequence(std::move(readEvents.front()));
|
|
readEvents.pop_front();
|
|
FAIL_FAST_IF(!(readEvents.empty()));
|
|
}
|
|
}
|
|
return Status;
|
|
}
|
|
catch (...)
|
|
{
|
|
return NTSTATUS_FROM_HRESULT(wil::ResultFromCaughtException());
|
|
}
|
|
}
|
|
|
|
// Routine Description:
|
|
// - Retrieves input records from the given input object and returns them to the client.
|
|
// - The peek version will NOT remove records when it copies them out.
|
|
// - The A version will convert to W using the console's current Input codepage (see SetConsoleCP)
|
|
// Arguments:
|
|
// - context - The input buffer to take records from to return to the client
|
|
// - outEvents - storage location for read events
|
|
// - eventsToRead - The number of input events to read
|
|
// - readHandleState - A structure that will help us maintain
|
|
// some input context across various calls on the same input
|
|
// handle. Primarily used to restore the "other piece" of partially
|
|
// returned strings (because client buffer wasn't big enough) on the
|
|
// next call.
|
|
// - waiter - If we have to wait (not enough data to fill client
|
|
// buffer), this contains context that will allow the server to
|
|
// restore this call later.
|
|
[[nodiscard]] HRESULT ApiRoutines::PeekConsoleInputAImpl(IConsoleInputObject& context,
|
|
std::deque<std::unique_ptr<IInputEvent>>& outEvents,
|
|
const size_t eventsToRead,
|
|
INPUT_READ_HANDLE_DATA& readHandleState,
|
|
std::unique_ptr<IWaitRoutine>& waiter) noexcept
|
|
{
|
|
try
|
|
{
|
|
NTSTATUS Status = _DoGetConsoleInput(context,
|
|
outEvents,
|
|
eventsToRead,
|
|
readHandleState,
|
|
false,
|
|
true,
|
|
waiter);
|
|
if (CONSOLE_STATUS_WAIT == Status)
|
|
{
|
|
return HRESULT_FROM_NT(Status);
|
|
}
|
|
RETURN_NTSTATUS(Status);
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
// Routine Description:
|
|
// - Retrieves input records from the given input object and returns them to the client.
|
|
// - The peek version will NOT remove records when it copies them out.
|
|
// - The W version accepts UCS-2 formatted characters (wide characters)
|
|
// Arguments:
|
|
// - context - The input buffer to take records from to return to the client
|
|
// - outEvents - storage location for read events
|
|
// - eventsToRead - The number of input events to read
|
|
// - readHandleState - A structure that will help us maintain
|
|
// some input context across various calls on the same input
|
|
// handle. Primarily used to restore the "other piece" of partially
|
|
// returned strings (because client buffer wasn't big enough) on the
|
|
// next call.
|
|
// - waiter - If we have to wait (not enough data to fill client
|
|
// buffer), this contains context that will allow the server to
|
|
// restore this call later.
|
|
[[nodiscard]] HRESULT ApiRoutines::PeekConsoleInputWImpl(IConsoleInputObject& context,
|
|
std::deque<std::unique_ptr<IInputEvent>>& outEvents,
|
|
const size_t eventsToRead,
|
|
INPUT_READ_HANDLE_DATA& readHandleState,
|
|
std::unique_ptr<IWaitRoutine>& waiter) noexcept
|
|
{
|
|
try
|
|
{
|
|
NTSTATUS Status = _DoGetConsoleInput(context,
|
|
outEvents,
|
|
eventsToRead,
|
|
readHandleState,
|
|
true,
|
|
true,
|
|
waiter);
|
|
if (CONSOLE_STATUS_WAIT == Status)
|
|
{
|
|
return HRESULT_FROM_NT(Status);
|
|
}
|
|
RETURN_NTSTATUS(Status);
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
// Routine Description:
|
|
// - Retrieves input records from the given input object and returns them to the client.
|
|
// - The read version WILL remove records when it copies them out.
|
|
// - The A version will convert to W using the console's current Input codepage (see SetConsoleCP)
|
|
// Arguments:
|
|
// - context - The input buffer to take records from to return to the client
|
|
// - outEvents - storage location for read events
|
|
// - eventsToRead - The number of input events to read
|
|
// - readHandleState - A structure that will help us maintain
|
|
// some input context across various calls on the same input
|
|
// handle. Primarily used to restore the "other piece" of partially
|
|
// returned strings (because client buffer wasn't big enough) on the
|
|
// next call.
|
|
// - waiter - If we have to wait (not enough data to fill client
|
|
// buffer), this contains context that will allow the server to
|
|
// restore this call later.
|
|
[[nodiscard]] HRESULT ApiRoutines::ReadConsoleInputAImpl(IConsoleInputObject& context,
|
|
std::deque<std::unique_ptr<IInputEvent>>& outEvents,
|
|
const size_t eventsToRead,
|
|
INPUT_READ_HANDLE_DATA& readHandleState,
|
|
std::unique_ptr<IWaitRoutine>& waiter) noexcept
|
|
{
|
|
try
|
|
{
|
|
NTSTATUS Status = _DoGetConsoleInput(context,
|
|
outEvents,
|
|
eventsToRead,
|
|
readHandleState,
|
|
false,
|
|
false,
|
|
waiter);
|
|
if (CONSOLE_STATUS_WAIT == Status)
|
|
{
|
|
return HRESULT_FROM_NT(Status);
|
|
}
|
|
RETURN_NTSTATUS(Status);
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
// Routine Description:
|
|
// - Retrieves input records from the given input object and returns them to the client.
|
|
// - The read version WILL remove records when it copies them out.
|
|
// - The W version accepts UCS-2 formatted characters (wide characters)
|
|
// Arguments:
|
|
// - context - The input buffer to take records from to return to the client
|
|
// - outEvents - storage location for read events
|
|
// - eventsToRead - The number of input events to read
|
|
// - readHandleState - A structure that will help us maintain
|
|
// some input context across various calls on the same input
|
|
// handle. Primarily used to restore the "other piece" of partially
|
|
// returned strings (because client buffer wasn't big enough) on the
|
|
// next call.
|
|
// - waiter - If we have to wait (not enough data to fill client
|
|
// buffer), this contains context that will allow the server to
|
|
// restore this call later.
|
|
[[nodiscard]] HRESULT ApiRoutines::ReadConsoleInputWImpl(IConsoleInputObject& context,
|
|
std::deque<std::unique_ptr<IInputEvent>>& outEvents,
|
|
const size_t eventsToRead,
|
|
INPUT_READ_HANDLE_DATA& readHandleState,
|
|
std::unique_ptr<IWaitRoutine>& waiter) noexcept
|
|
{
|
|
try
|
|
{
|
|
NTSTATUS Status = _DoGetConsoleInput(context,
|
|
outEvents,
|
|
eventsToRead,
|
|
readHandleState,
|
|
true,
|
|
false,
|
|
waiter);
|
|
if (CONSOLE_STATUS_WAIT == Status)
|
|
{
|
|
return HRESULT_FROM_NT(Status);
|
|
}
|
|
RETURN_NTSTATUS(Status);
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
// Routine Description:
|
|
// - Writes events to the input buffer
|
|
// Arguments:
|
|
// - context - the input buffer to write to
|
|
// - events - the events to written
|
|
// - written - on output, the number of events written
|
|
// - append - true if events should be written to the end of the input
|
|
// buffer, false if they should be written to the front
|
|
// Return Value:
|
|
// - HRESULT indicating success or failure
|
|
[[nodiscard]] static HRESULT _WriteConsoleInputWImplHelper(InputBuffer& context,
|
|
std::deque<std::unique_ptr<IInputEvent>>& events,
|
|
size_t& written,
|
|
const bool append) noexcept
|
|
{
|
|
try
|
|
{
|
|
written = 0;
|
|
|
|
// add to InputBuffer
|
|
if (append)
|
|
{
|
|
written = context.Write(events);
|
|
}
|
|
else
|
|
{
|
|
written = context.Prepend(events);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
// Routine Description:
|
|
// - Writes events to the input buffer already formed into IInputEvents (private call)
|
|
// Arguments:
|
|
// - context - the input buffer to write to
|
|
// - events - the events to written
|
|
// - written - on output, the number of events written
|
|
// - append - true if events should be written to the end of the input
|
|
// buffer, false if they should be written to the front
|
|
// Return Value:
|
|
// - HRESULT indicating success or failure
|
|
[[nodiscard]] HRESULT DoSrvPrivateWriteConsoleInputW(_Inout_ InputBuffer* const pInputBuffer,
|
|
_Inout_ std::deque<std::unique_ptr<IInputEvent>>& events,
|
|
_Out_ size_t& eventsWritten,
|
|
const bool append) noexcept
|
|
{
|
|
return _WriteConsoleInputWImplHelper(*pInputBuffer, events, eventsWritten, append);
|
|
}
|
|
|
|
// Routine Description:
|
|
// - Writes events to the input buffer, translating from codepage to unicode first
|
|
// Arguments:
|
|
// - context - the input buffer to write to
|
|
// - buffer - the events to written
|
|
// - written - on output, the number of events written
|
|
// - append - true if events should be written to the end of the input
|
|
// buffer, false if they should be written to the front
|
|
// Return Value:
|
|
// - HRESULT indicating success or failure
|
|
[[nodiscard]] HRESULT ApiRoutines::WriteConsoleInputAImpl(InputBuffer& context,
|
|
const gsl::span<const INPUT_RECORD> buffer,
|
|
size_t& written,
|
|
const bool append) noexcept
|
|
{
|
|
written = 0;
|
|
|
|
LockConsole();
|
|
auto Unlock = wil::scope_exit([&] { UnlockConsole(); });
|
|
|
|
try
|
|
{
|
|
auto events = IInputEvent::Create(buffer);
|
|
|
|
// add partial byte event if necessary
|
|
if (context.IsWritePartialByteSequenceAvailable())
|
|
{
|
|
events.push_front(context.FetchWritePartialByteSequence(false));
|
|
}
|
|
|
|
// convert to unicode if necessary
|
|
std::unique_ptr<IInputEvent> partialEvent;
|
|
EventsToUnicode(events, partialEvent);
|
|
|
|
if (partialEvent.get())
|
|
{
|
|
context.StoreWritePartialByteSequence(std::move(partialEvent));
|
|
}
|
|
|
|
return _WriteConsoleInputWImplHelper(context, events, written, append);
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
// Routine Description:
|
|
// - Writes events to the input buffer
|
|
// Arguments:
|
|
// - context - the input buffer to write to
|
|
// - buffer - the events to written
|
|
// - written - on output, the number of events written
|
|
// - append - true if events should be written to the end of the input
|
|
// buffer, false if they should be written to the front
|
|
// Return Value:
|
|
// - HRESULT indicating success or failure
|
|
[[nodiscard]] HRESULT ApiRoutines::WriteConsoleInputWImpl(InputBuffer& context,
|
|
const gsl::span<const INPUT_RECORD> buffer,
|
|
size_t& written,
|
|
const bool append) noexcept
|
|
{
|
|
written = 0;
|
|
|
|
LockConsole();
|
|
auto Unlock = wil::scope_exit([&] { UnlockConsole(); });
|
|
|
|
try
|
|
{
|
|
auto events = IInputEvent::Create(buffer);
|
|
|
|
return _WriteConsoleInputWImplHelper(context, events, written, append);
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
// Function Description:
|
|
// - Writes the input KeyEvent to the console as a console control event. This
|
|
// can be used for potentially generating Ctrl-C events, as
|
|
// HandleGenericKeyEvent will correctly generate the Ctrl-C response in
|
|
// the same way that it'd be handled from the window proc, with the proper
|
|
// processed vs raw input handling.
|
|
// If the input key is *not* a Ctrl-C key, then it will get written to the
|
|
// buffer just the same as any other KeyEvent.
|
|
// Arguments:
|
|
// - pInputBuffer - the input buffer to write to. Currently unused, as
|
|
// HandleGenericKeyEvent just gets the global input buffer, but all
|
|
// ConGetSet API's require an input or output object.
|
|
// - key - The keyevent to send to the console.
|
|
// Return Value:
|
|
// - HRESULT indicating success or failure
|
|
[[nodiscard]] HRESULT DoSrvPrivateWriteConsoleControlInput(_Inout_ InputBuffer* const /*pInputBuffer*/,
|
|
_In_ KeyEvent key)
|
|
{
|
|
LockConsole();
|
|
auto Unlock = wil::scope_exit([&] { UnlockConsole(); });
|
|
|
|
HandleGenericKeyEvent(key, false);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// Routine Description:
|
|
// - This is used when the app is reading output as cells and needs them converted
|
|
// into a particular codepage on the way out.
|
|
// Arguments:
|
|
// - codepage - The relevant codepage for translation
|
|
// - buffer - This is the buffer containing all of the character data to be converted
|
|
// - rectangle - This is the rectangle describing the region that the buffer covers.
|
|
// Return Value:
|
|
// - Generally S_OK. Could be a memory or math error code.
|
|
[[nodiscard]] static HRESULT _ConvertCellsToAInplace(const UINT codepage,
|
|
const gsl::span<CHAR_INFO> buffer,
|
|
const Viewport rectangle) noexcept
|
|
{
|
|
try
|
|
{
|
|
std::vector<CHAR_INFO> tempBuffer(buffer.begin(), buffer.end());
|
|
|
|
const auto size = rectangle.Dimensions();
|
|
auto tempIter = tempBuffer.cbegin();
|
|
auto outIter = buffer.begin();
|
|
|
|
for (int i = 0; i < size.Y; i++)
|
|
{
|
|
for (int j = 0; j < size.X; j++)
|
|
{
|
|
// Any time we see the lead flag, we presume there will be a trailing one following it.
|
|
// Giving us two bytes of space (one per cell in the ascii part of the character union)
|
|
// to fill with whatever this Unicode character converts into.
|
|
if (WI_IsFlagSet(tempIter->Attributes, COMMON_LVB_LEADING_BYTE))
|
|
{
|
|
// As long as we're not looking at the exact last column of the buffer...
|
|
if (j < size.X - 1)
|
|
{
|
|
// Walk forward one because we're about to consume two cells.
|
|
j++;
|
|
|
|
// Try to convert the unicode character (2 bytes) in the leading cell to the codepage.
|
|
CHAR AsciiDbcs[2] = { 0 };
|
|
UINT NumBytes = gsl::narrow<UINT>(sizeof(AsciiDbcs));
|
|
NumBytes = ConvertToOem(codepage, &tempIter->Char.UnicodeChar, 1, &AsciiDbcs[0], NumBytes);
|
|
|
|
// Fill the 1 byte (AsciiChar) portion of the leading and trailing cells with each of the bytes returned.
|
|
outIter->Char.AsciiChar = AsciiDbcs[0];
|
|
outIter->Attributes = tempIter->Attributes;
|
|
outIter++;
|
|
tempIter++;
|
|
outIter->Char.AsciiChar = AsciiDbcs[1];
|
|
outIter->Attributes = tempIter->Attributes;
|
|
outIter++;
|
|
tempIter++;
|
|
}
|
|
else
|
|
{
|
|
// When we're in the last column with only a leading byte, we can't return that without a trailing.
|
|
// Instead, replace the output data with just a space and clear all flags.
|
|
outIter->Char.AsciiChar = UNICODE_SPACE;
|
|
outIter->Attributes = tempIter->Attributes;
|
|
WI_ClearAllFlags(outIter->Attributes, COMMON_LVB_SBCSDBCS);
|
|
outIter++;
|
|
tempIter++;
|
|
}
|
|
}
|
|
else if (WI_AreAllFlagsClear(tempIter->Attributes, COMMON_LVB_SBCSDBCS))
|
|
{
|
|
// If there are no leading/trailing pair flags, then we only have 1 ascii byte to try to fit the
|
|
// 2 byte UTF-16 character into. Give it a go.
|
|
ConvertToOem(codepage, &tempIter->Char.UnicodeChar, 1, &outIter->Char.AsciiChar, 1);
|
|
outIter->Attributes = tempIter->Attributes;
|
|
outIter++;
|
|
tempIter++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
// Routine Description:
|
|
// - This is used when the app writes oem to the output buffer we want
|
|
// UnicodeOem or Unicode in the buffer, depending on font
|
|
// Arguments:
|
|
// - codepage - The relevant codepage for translation
|
|
// - buffer - This is the buffer containing all of the character data to be converted
|
|
// - rectangle - This is the rectangle describing the region that the buffer covers.
|
|
// Return Value:
|
|
// - Generally S_OK. Could be a memory or math error code.
|
|
[[nodiscard]] static HRESULT _ConvertCellsToWInplace(const UINT codepage,
|
|
gsl::span<CHAR_INFO> buffer,
|
|
const Viewport& rectangle) noexcept
|
|
{
|
|
try
|
|
{
|
|
const auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
|
|
|
|
const auto size = rectangle.Dimensions();
|
|
auto outIter = buffer.begin();
|
|
|
|
for (int i = 0; i < size.Y; i++)
|
|
{
|
|
for (int j = 0; j < size.X; j++)
|
|
{
|
|
// Clear lead/trailing flags. We'll determine it for ourselves versus the given codepage.
|
|
WI_ClearAllFlags(outIter->Attributes, COMMON_LVB_SBCSDBCS);
|
|
|
|
// If the 1 byte given is a lead in this codepage, we likely need two cells for the width.
|
|
if (IsDBCSLeadByteConsole(outIter->Char.AsciiChar, &gci.OutputCPInfo))
|
|
{
|
|
// If we're not on the last column, we have two cells to use.
|
|
if (j < size.X - 1)
|
|
{
|
|
// Mark we're consuming two cells.
|
|
j++;
|
|
|
|
// Grab the lead/trailing byte pair from this cell and the next one forward.
|
|
CHAR AsciiDbcs[2];
|
|
AsciiDbcs[0] = outIter->Char.AsciiChar;
|
|
AsciiDbcs[1] = (outIter + 1)->Char.AsciiChar;
|
|
|
|
// Convert it to UTF-16.
|
|
WCHAR UnicodeDbcs[2];
|
|
ConvertOutputToUnicode(codepage, &AsciiDbcs[0], 2, &UnicodeDbcs[0], 2);
|
|
|
|
// Store the actual character in the first available position.
|
|
outIter->Char.UnicodeChar = UnicodeDbcs[0];
|
|
WI_ClearAllFlags(outIter->Attributes, COMMON_LVB_SBCSDBCS);
|
|
WI_SetFlag(outIter->Attributes, COMMON_LVB_LEADING_BYTE);
|
|
outIter++;
|
|
|
|
// Put a padding character in the second position.
|
|
outIter->Char.UnicodeChar = UNICODE_DBCS_PADDING;
|
|
WI_ClearAllFlags(outIter->Attributes, COMMON_LVB_SBCSDBCS);
|
|
WI_SetFlag(outIter->Attributes, COMMON_LVB_TRAILING_BYTE);
|
|
outIter++;
|
|
}
|
|
else
|
|
{
|
|
// If we were on the last column, put in a space.
|
|
outIter->Char.UnicodeChar = UNICODE_SPACE;
|
|
WI_ClearAllFlags(outIter->Attributes, COMMON_LVB_SBCSDBCS);
|
|
outIter++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If it's not detected as a lead byte of a pair, then just convert it in place and move on.
|
|
CHAR c = outIter->Char.AsciiChar;
|
|
|
|
ConvertOutputToUnicode(codepage, &c, 1, &outIter->Char.UnicodeChar, 1);
|
|
outIter++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
[[nodiscard]] static std::vector<CHAR_INFO> _ConvertCellsToMungedW(gsl::span<CHAR_INFO> buffer, const Viewport& rectangle)
|
|
{
|
|
std::vector<CHAR_INFO> result;
|
|
result.reserve(buffer.size() * 2); // we estimate we'll need up to double the cells if they all expand.
|
|
|
|
const auto size = rectangle.Dimensions();
|
|
auto bufferIter = buffer.begin();
|
|
|
|
for (SHORT i = 0; i < size.Y; i++)
|
|
{
|
|
for (SHORT j = 0; j < size.X; j++)
|
|
{
|
|
// Prepare a candidate charinfo on the output side copying the colors but not the lead/trail information.
|
|
CHAR_INFO candidate;
|
|
candidate.Attributes = bufferIter->Attributes;
|
|
WI_ClearAllFlags(candidate.Attributes, COMMON_LVB_SBCSDBCS);
|
|
|
|
// If the glyph we're given is full width, it needs to take two cells.
|
|
if (IsGlyphFullWidth(bufferIter->Char.UnicodeChar))
|
|
{
|
|
// If we're not on the final cell of the row...
|
|
if (j < size.X - 1)
|
|
{
|
|
// Mark that we're consuming two cells.
|
|
j++;
|
|
|
|
// Fill one cell with a copy of the color and character marked leading
|
|
candidate.Char.UnicodeChar = bufferIter->Char.UnicodeChar;
|
|
WI_SetFlag(candidate.Attributes, COMMON_LVB_LEADING_BYTE);
|
|
result.push_back(candidate);
|
|
|
|
// Fill a second cell with a copy of the color marked trailing and a padding character.
|
|
candidate.Char.UnicodeChar = UNICODE_DBCS_PADDING;
|
|
candidate.Attributes = bufferIter->Attributes;
|
|
WI_ClearAllFlags(candidate.Attributes, COMMON_LVB_SBCSDBCS);
|
|
WI_SetFlag(candidate.Attributes, COMMON_LVB_TRAILING_BYTE);
|
|
}
|
|
else
|
|
{
|
|
// If we're on the final cell, this won't fit. Replace with a space.
|
|
candidate.Char.UnicodeChar = UNICODE_SPACE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If we're not full-width, we're half-width. Just copy the character over.
|
|
candidate.Char.UnicodeChar = bufferIter->Char.UnicodeChar;
|
|
}
|
|
|
|
// Push our candidate in.
|
|
result.push_back(candidate);
|
|
|
|
// Advance to read the next item.
|
|
bufferIter++;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
[[nodiscard]] static HRESULT _ReadConsoleOutputWImplHelper(const SCREEN_INFORMATION& context,
|
|
gsl::span<CHAR_INFO> targetBuffer,
|
|
const Microsoft::Console::Types::Viewport& requestRectangle,
|
|
Microsoft::Console::Types::Viewport& readRectangle) noexcept
|
|
{
|
|
try
|
|
{
|
|
const auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
|
|
const auto& storageBuffer = context.GetActiveBuffer();
|
|
const auto storageSize = storageBuffer.GetBufferSize().Dimensions();
|
|
|
|
const auto targetSize = requestRectangle.Dimensions();
|
|
|
|
// If either dimension of the request is too small, return an empty rectangle as read and exit early.
|
|
if (targetSize.X <= 0 || targetSize.Y <= 0)
|
|
{
|
|
readRectangle = Viewport::FromDimensions(requestRectangle.Origin(), { 0, 0 });
|
|
return S_OK;
|
|
}
|
|
|
|
// The buffer given should be big enough to hold the dimensions of the request.
|
|
size_t targetArea;
|
|
RETURN_IF_FAILED(SizeTMult(targetSize.X, targetSize.Y, &targetArea));
|
|
RETURN_HR_IF(E_INVALIDARG, targetArea < targetBuffer.size());
|
|
|
|
// Clip the request rectangle to the size of the storage buffer
|
|
SMALL_RECT clip = requestRectangle.ToExclusive();
|
|
clip.Right = std::min(clip.Right, storageSize.X);
|
|
clip.Bottom = std::min(clip.Bottom, storageSize.Y);
|
|
|
|
// Find the target point (where to write the user's buffer)
|
|
// It will either be 0,0 or offset into the buffer by the inverse of the negative values.
|
|
COORD targetPoint;
|
|
targetPoint.X = clip.Left < 0 ? -clip.Left : 0;
|
|
targetPoint.Y = clip.Top < 0 ? -clip.Top : 0;
|
|
|
|
// The clipped rect must be inside the buffer size, so it has a minimum value of 0. (max of itself and 0)
|
|
clip.Left = std::max(clip.Left, 0i16);
|
|
clip.Top = std::max(clip.Top, 0i16);
|
|
|
|
// The final "request rectangle" or the area inside the buffer we want to read, is the clipped dimensions.
|
|
const auto clippedRequestRectangle = Viewport::FromExclusive(clip);
|
|
|
|
// We will start reading the buffer at the point of the top left corner (origin) of the (potentially adjusted) request
|
|
const auto sourcePoint = clippedRequestRectangle.Origin();
|
|
|
|
// Get an iterator to the beginning of the return buffer
|
|
// We might have to seek this forward or skip around if we clipped the request.
|
|
auto targetIter = targetBuffer.begin();
|
|
COORD targetPos = { 0 };
|
|
const auto targetLimit = Viewport::FromDimensions(targetPoint, clippedRequestRectangle.Dimensions());
|
|
|
|
// Get an iterator to the beginning of the request inside the screen buffer
|
|
// This should walk exactly along every cell of the clipped request.
|
|
auto sourceIter = storageBuffer.GetCellDataAt(sourcePoint, clippedRequestRectangle);
|
|
|
|
// Walk through every cell of the target, advancing the buffer.
|
|
// Validate that we always still have a valid iterator to the backing store,
|
|
// that we always are writing inside the user's buffer (before the end)
|
|
// and we're always targeting the user's buffer inside its original bounds.
|
|
while (sourceIter && targetIter < targetBuffer.end())
|
|
{
|
|
// If the point we're trying to write is inside the limited buffer write zone...
|
|
if (targetLimit.IsInBounds(targetPos))
|
|
{
|
|
// Copy the data into position...
|
|
*targetIter = gci.AsCharInfo(*sourceIter);
|
|
// ... and advance the read iterator.
|
|
sourceIter++;
|
|
}
|
|
|
|
// Always advance the write iterator, we might have skipped it due to clipping.
|
|
targetIter++;
|
|
|
|
// Increment the target
|
|
targetPos.X++;
|
|
if (targetPos.X >= targetSize.X)
|
|
{
|
|
targetPos.X = 0;
|
|
targetPos.Y++;
|
|
}
|
|
}
|
|
|
|
// Reply with the region we read out of the backing buffer (potentially clipped)
|
|
readRectangle = clippedRequestRectangle;
|
|
|
|
return S_OK;
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
[[nodiscard]] HRESULT ApiRoutines::ReadConsoleOutputAImpl(const SCREEN_INFORMATION& context,
|
|
gsl::span<CHAR_INFO> buffer,
|
|
const Microsoft::Console::Types::Viewport& sourceRectangle,
|
|
Microsoft::Console::Types::Viewport& readRectangle) noexcept
|
|
{
|
|
LockConsole();
|
|
auto Unlock = wil::scope_exit([&] { UnlockConsole(); });
|
|
|
|
try
|
|
{
|
|
const auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
|
|
const auto codepage = gci.OutputCP;
|
|
|
|
RETURN_IF_FAILED(_ReadConsoleOutputWImplHelper(context, buffer, sourceRectangle, readRectangle));
|
|
|
|
LOG_IF_FAILED(_ConvertCellsToAInplace(codepage, buffer, readRectangle));
|
|
|
|
return S_OK;
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
[[nodiscard]] HRESULT ApiRoutines::ReadConsoleOutputWImpl(const SCREEN_INFORMATION& context,
|
|
gsl::span<CHAR_INFO> buffer,
|
|
const Microsoft::Console::Types::Viewport& sourceRectangle,
|
|
Microsoft::Console::Types::Viewport& readRectangle) noexcept
|
|
{
|
|
LockConsole();
|
|
auto Unlock = wil::scope_exit([&] { UnlockConsole(); });
|
|
|
|
try
|
|
{
|
|
RETURN_IF_FAILED(_ReadConsoleOutputWImplHelper(context, buffer, sourceRectangle, readRectangle));
|
|
|
|
if (!context.GetActiveBuffer().GetCurrentFont().IsTrueTypeFont())
|
|
{
|
|
// For compatibility reasons, we must maintain the behavior that munges the data if we are writing while a raster font is enabled.
|
|
// This can be removed when raster font support is removed.
|
|
UnicodeRasterFontCellMungeOnRead(buffer);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
[[nodiscard]] static HRESULT _WriteConsoleOutputWImplHelper(SCREEN_INFORMATION& context,
|
|
gsl::span<CHAR_INFO> buffer,
|
|
const Viewport& requestRectangle,
|
|
Viewport& writtenRectangle) noexcept
|
|
{
|
|
try
|
|
{
|
|
auto& storageBuffer = context.GetActiveBuffer();
|
|
const auto storageRectangle = storageBuffer.GetBufferSize();
|
|
const auto storageSize = storageRectangle.Dimensions();
|
|
|
|
const auto sourceSize = requestRectangle.Dimensions();
|
|
|
|
// If either dimension of the request is too small, return an empty rectangle as the read and exit early.
|
|
if (sourceSize.X <= 0 || sourceSize.Y <= 0)
|
|
{
|
|
writtenRectangle = Viewport::FromDimensions(requestRectangle.Origin(), { 0, 0 });
|
|
return S_OK;
|
|
}
|
|
|
|
// If the top and left of the destination we're trying to write it outside the buffer,
|
|
// give the original request rectangle back and exit early OK.
|
|
if (requestRectangle.Left() >= storageSize.X || requestRectangle.Top() >= storageSize.Y)
|
|
{
|
|
writtenRectangle = requestRectangle;
|
|
return S_OK;
|
|
}
|
|
|
|
// Do clipping according to the legacy patterns.
|
|
SMALL_RECT writeRegion = requestRectangle.ToInclusive();
|
|
SMALL_RECT sourceRect;
|
|
if (writeRegion.Right > storageSize.X - 1)
|
|
{
|
|
writeRegion.Right = storageSize.X - 1;
|
|
}
|
|
sourceRect.Right = writeRegion.Right - writeRegion.Left;
|
|
if (writeRegion.Bottom > storageSize.Y - 1)
|
|
{
|
|
writeRegion.Bottom = storageSize.Y - 1;
|
|
}
|
|
sourceRect.Bottom = writeRegion.Bottom - writeRegion.Top;
|
|
|
|
if (writeRegion.Left < 0)
|
|
{
|
|
sourceRect.Left = -writeRegion.Left;
|
|
writeRegion.Left = 0;
|
|
}
|
|
else
|
|
{
|
|
sourceRect.Left = 0;
|
|
}
|
|
|
|
if (writeRegion.Top < 0)
|
|
{
|
|
sourceRect.Top = -writeRegion.Top;
|
|
writeRegion.Top = 0;
|
|
}
|
|
else
|
|
{
|
|
sourceRect.Top = 0;
|
|
}
|
|
|
|
if (sourceRect.Left > sourceRect.Right || sourceRect.Top > sourceRect.Bottom)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
const auto writeRectangle = Viewport::FromInclusive(writeRegion);
|
|
|
|
auto target = writeRectangle.Origin();
|
|
|
|
// For every row in the request, create a view into the clamped portion of just the one line to write.
|
|
// This allows us to restrict the width of the call without allocating/copying any memory by just making
|
|
// a smaller view over the existing big blob of data from the original call.
|
|
for (; target.Y < writeRectangle.BottomExclusive(); target.Y++)
|
|
{
|
|
// We find the offset into the original buffer by the dimensions of the original request rectangle.
|
|
ptrdiff_t rowOffset = 0;
|
|
RETURN_IF_FAILED(PtrdiffTSub(target.Y, requestRectangle.Top(), &rowOffset));
|
|
RETURN_IF_FAILED(PtrdiffTMult(rowOffset, requestRectangle.Width(), &rowOffset));
|
|
|
|
ptrdiff_t colOffset = 0;
|
|
RETURN_IF_FAILED(PtrdiffTSub(target.X, requestRectangle.Left(), &colOffset));
|
|
|
|
ptrdiff_t totalOffset = 0;
|
|
RETURN_IF_FAILED(PtrdiffTAdd(rowOffset, colOffset, &totalOffset));
|
|
|
|
// Now we make a subspan starting from that offset for as much of the original request as would fit
|
|
const auto subspan = buffer.subspan(totalOffset, writeRectangle.Width());
|
|
|
|
// Convert to a CHAR_INFO view to fit into the iterator
|
|
const auto charInfos = gsl::span<const CHAR_INFO>(subspan.data(), subspan.size());
|
|
|
|
// Make the iterator and write to the target position.
|
|
OutputCellIterator it(charInfos);
|
|
storageBuffer.Write(it, target);
|
|
}
|
|
|
|
// Since we've managed to write part of the request, return the clamped part that we actually used.
|
|
writtenRectangle = writeRectangle;
|
|
|
|
return S_OK;
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
[[nodiscard]] HRESULT ApiRoutines::WriteConsoleOutputAImpl(SCREEN_INFORMATION& context,
|
|
gsl::span<CHAR_INFO> buffer,
|
|
const Viewport& requestRectangle,
|
|
Viewport& writtenRectangle) noexcept
|
|
{
|
|
LockConsole();
|
|
auto Unlock = wil::scope_exit([&] { UnlockConsole(); });
|
|
|
|
try
|
|
{
|
|
const CONSOLE_INFORMATION& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
|
|
const auto codepage = gci.OutputCP;
|
|
LOG_IF_FAILED(_ConvertCellsToWInplace(codepage, buffer, requestRectangle));
|
|
|
|
RETURN_IF_FAILED(_WriteConsoleOutputWImplHelper(context, buffer, requestRectangle, writtenRectangle));
|
|
|
|
return S_OK;
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
[[nodiscard]] HRESULT ApiRoutines::WriteConsoleOutputWImpl(SCREEN_INFORMATION& context,
|
|
gsl::span<CHAR_INFO> buffer,
|
|
const Viewport& requestRectangle,
|
|
Viewport& writtenRectangle) noexcept
|
|
{
|
|
LockConsole();
|
|
auto Unlock = wil::scope_exit([&] { UnlockConsole(); });
|
|
|
|
try
|
|
{
|
|
if (!context.GetActiveBuffer().GetCurrentFont().IsTrueTypeFont())
|
|
{
|
|
// For compatibility reasons, we must maintain the behavior that munges the data if we are writing while a raster font is enabled.
|
|
// This can be removed when raster font support is removed.
|
|
auto translated = _ConvertCellsToMungedW(buffer, requestRectangle);
|
|
RETURN_IF_FAILED(_WriteConsoleOutputWImplHelper(context, translated, requestRectangle, writtenRectangle));
|
|
}
|
|
else
|
|
{
|
|
RETURN_IF_FAILED(_WriteConsoleOutputWImplHelper(context, buffer, requestRectangle, writtenRectangle));
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
[[nodiscard]] HRESULT ApiRoutines::ReadConsoleOutputAttributeImpl(const SCREEN_INFORMATION& context,
|
|
const COORD origin,
|
|
gsl::span<WORD> buffer,
|
|
size_t& written) noexcept
|
|
{
|
|
written = 0;
|
|
|
|
LockConsole();
|
|
auto Unlock = wil::scope_exit([&] { UnlockConsole(); });
|
|
|
|
try
|
|
{
|
|
const auto attrs = ReadOutputAttributes(context.GetActiveBuffer(), origin, buffer.size());
|
|
std::copy(attrs.cbegin(), attrs.cend(), buffer.begin());
|
|
written = attrs.size();
|
|
|
|
return S_OK;
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
[[nodiscard]] HRESULT ApiRoutines::ReadConsoleOutputCharacterAImpl(const SCREEN_INFORMATION& context,
|
|
const COORD origin,
|
|
gsl::span<char> buffer,
|
|
size_t& written) noexcept
|
|
{
|
|
written = 0;
|
|
|
|
LockConsole();
|
|
auto Unlock = wil::scope_exit([&] { UnlockConsole(); });
|
|
|
|
try
|
|
{
|
|
const auto chars = ReadOutputStringA(context.GetActiveBuffer(),
|
|
origin,
|
|
buffer.size());
|
|
|
|
// for compatibility reasons, if we receive more chars than can fit in the buffer
|
|
// then we don't send anything back.
|
|
if (chars.size() <= buffer.size())
|
|
{
|
|
std::copy(chars.cbegin(), chars.cend(), buffer.begin());
|
|
written = chars.size();
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
[[nodiscard]] HRESULT ApiRoutines::ReadConsoleOutputCharacterWImpl(const SCREEN_INFORMATION& context,
|
|
const COORD origin,
|
|
gsl::span<wchar_t> buffer,
|
|
size_t& written) noexcept
|
|
{
|
|
written = 0;
|
|
|
|
LockConsole();
|
|
auto Unlock = wil::scope_exit([&] { UnlockConsole(); });
|
|
|
|
try
|
|
{
|
|
const auto chars = ReadOutputStringW(context.GetActiveBuffer(),
|
|
origin,
|
|
buffer.size());
|
|
|
|
// Only copy if the whole result will fit.
|
|
if (chars.size() <= buffer.size())
|
|
{
|
|
std::copy(chars.cbegin(), chars.cend(), buffer.begin());
|
|
written = chars.size();
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
CATCH_RETURN();
|
|
}
|
|
|
|
// There used to be a text mode and a graphics mode flag.
|
|
// Text mode was used for regular applications like CMD.exe.
|
|
// Graphics mode was used for bitmap VDM buffers and is no longer supported.
|
|
// OEM console font mode used to represent rewriting the entire buffer into codepage 437 so the renderer could handle it with raster fonts.
|
|
// But now the entire buffer is always kept in Unicode and the renderer asks for translation when/if necessary for raster fonts only.
|
|
// We keep these definitions here so the API can enforce that the only one we support any longer is the original text mode.
|
|
// See: https://msdn.microsoft.com/en-us/library/windows/desktop/ms682122(v=vs.85).aspx
|
|
#define CONSOLE_TEXTMODE_BUFFER 1
|
|
//#define CONSOLE_GRAPHICS_BUFFER 2
|
|
//#define CONSOLE_OEMFONT_DISPLAY 4
|
|
|
|
[[nodiscard]] NTSTATUS ConsoleCreateScreenBuffer(std::unique_ptr<ConsoleHandleData>& handle,
|
|
_In_ PCONSOLE_API_MSG /*Message*/,
|
|
_In_ PCD_CREATE_OBJECT_INFORMATION Information,
|
|
_In_ PCONSOLE_CREATESCREENBUFFER_MSG a)
|
|
{
|
|
Telemetry::Instance().LogApiCall(Telemetry::ApiCall::CreateConsoleScreenBuffer);
|
|
const CONSOLE_INFORMATION& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
|
|
|
|
// If any buffer type except the one we support is set, it's invalid.
|
|
if (WI_IsAnyFlagSet(a->Flags, ~CONSOLE_TEXTMODE_BUFFER))
|
|
{
|
|
// We no longer support anything other than a textmode buffer
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
ConsoleHandleData::HandleType const HandleType = ConsoleHandleData::HandleType::Output;
|
|
|
|
const SCREEN_INFORMATION& siExisting = gci.GetActiveOutputBuffer();
|
|
|
|
// Create new screen buffer.
|
|
COORD WindowSize = siExisting.GetViewport().Dimensions();
|
|
const FontInfo& existingFont = siExisting.GetCurrentFont();
|
|
SCREEN_INFORMATION* ScreenInfo = nullptr;
|
|
NTSTATUS Status = SCREEN_INFORMATION::CreateInstance(WindowSize,
|
|
existingFont,
|
|
WindowSize,
|
|
siExisting.GetAttributes(),
|
|
siExisting.GetAttributes(),
|
|
Cursor::CURSOR_SMALL_SIZE,
|
|
&ScreenInfo);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
Status = NTSTATUS_FROM_HRESULT(ScreenInfo->AllocateIoHandle(HandleType,
|
|
Information->DesiredAccess,
|
|
Information->ShareMode,
|
|
handle));
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
SCREEN_INFORMATION::s_InsertScreenBuffer(ScreenInfo);
|
|
|
|
Exit:
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
delete ScreenInfo;
|
|
}
|
|
|
|
return Status;
|
|
}
|