mirror of
https://github.com/reactos/reactos.git
synced 2024-08-19 18:02:55 +00:00
1389 lines
45 KiB
C
1389 lines
45 KiB
C
/*
|
|
* PROJECT: ReactOS Drivers
|
|
* LICENSE: BSD - See COPYING.ARM in the top level directory
|
|
* FILE: drivers/sac/driver/vtutf8chan.c
|
|
* PURPOSE: Driver for the Server Administration Console (SAC) for EMS
|
|
* PROGRAMMERS: ReactOS Portable Systems Group
|
|
*/
|
|
|
|
/* INCLUDES *******************************************************************/
|
|
|
|
#include "sacdrv.h"
|
|
|
|
/* GLOBALS ********************************************************************/
|
|
|
|
CHAR IncomingUtf8ConversionBuffer[4];
|
|
WCHAR IncomingUnicodeValue;
|
|
|
|
SAC_STATIC_ESCAPE_STRING SacStaticEscapeStrings [] =
|
|
{
|
|
{ VT_ANSI_CURSOR_UP, 2, SacCursorUp },
|
|
{ VT_ANSI_CURSOR_DOWN, 2, SacCursorDown },
|
|
{ VT_ANSI_CURSOR_RIGHT, 2, SacCursorRight },
|
|
{ VT_ANSI_CURSOR_LEFT, 2, SacCursorLeft },
|
|
{ VT_220_BACKTAB, 3, SacBackTab },
|
|
{ VT_ANSI_ERASE_END_LINE, 2, SacEraseEndOfLine },
|
|
{ VT_ANSI_ERASE_START_LINE, 3, SacEraseStartOfLine },
|
|
{ VT_ANSI_ERASE_ENTIRE_LINE, 3, SacEraseLine },
|
|
{ VT_ANSI_ERASE_DOWN_SCREEN, 2, SacEraseEndOfScreen },
|
|
{ VT_ANSI_ERASE_UP_SCREEN, 3, SacEraseStartOfScreen },
|
|
{ VT_ANSI_ERASE_ENTIRE_SCREEN, 3, SacEraseScreen },
|
|
};
|
|
|
|
/* FUNCTIONS ******************************************************************/
|
|
|
|
FORCEINLINE
|
|
VOID
|
|
VTUTF8ChannelAssertCursor(IN PSAC_CHANNEL Channel)
|
|
{
|
|
ASSERT(Channel->CursorRow < SAC_VTUTF8_ROW_HEIGHT);
|
|
ASSERT(Channel->CursorCol < SAC_VTUTF8_COL_WIDTH);
|
|
}
|
|
|
|
BOOLEAN
|
|
NTAPI
|
|
VTUTF8ChannelScanForNumber(IN PWCHAR String,
|
|
OUT PULONG Number)
|
|
{
|
|
/* If the first character is invalid, fail early */
|
|
if ((*String < L'0') || (*String > L'9')) return FALSE;
|
|
|
|
/* Otherwise, initialize the output and loop the string */
|
|
*Number = 0;
|
|
while ((*String >= L'0') && (*String <= L'9'))
|
|
{
|
|
/* Save the first decimal */
|
|
*Number = 10 * *Number;
|
|
|
|
/* Compute and add the second one */
|
|
*Number += *++String - L'0';
|
|
}
|
|
|
|
/* All done */
|
|
return TRUE;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VTUTF8ChannelAnsiDispatch(IN PSAC_CHANNEL Channel,
|
|
IN SAC_ANSI_DISPATCH AnsiCode,
|
|
IN INT* Data,
|
|
IN ULONG Length)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PCHAR LocalBuffer = NULL, Tmp;
|
|
INT l;
|
|
CHECK_PARAMETER1(Channel);
|
|
|
|
/* Check which ANSI sequence we should output */
|
|
switch (AnsiCode)
|
|
{
|
|
/* Send the [2J (Clear Screen and Reset Cursor) */
|
|
case SacAnsiClearScreen:
|
|
Tmp = "\x1B[2J";
|
|
break;
|
|
|
|
/* Send the [0J (Clear From Position Till End Of Screen) */
|
|
case SacAnsiClearEndOfScreen:
|
|
Tmp = "\x1B[0J";
|
|
break;
|
|
|
|
/* Send the [0K (Clear from Position Till End Of Line) */
|
|
case SacAnsiClearEndOfLine:
|
|
Tmp = "\x1B[0K";
|
|
break;
|
|
|
|
/* Send a combination of two [#m attribute changes */
|
|
case SacAnsiSetColors:
|
|
|
|
/* Allocate a small local buffer for it */
|
|
LocalBuffer = SacAllocatePool(SAC_VTUTF8_COL_WIDTH, GLOBAL_BLOCK_TAG);
|
|
CHECK_ALLOCATION(LocalBuffer);
|
|
|
|
/* Caller should have sent two colors as two integers */
|
|
if (!(Data) || (Length != 8))
|
|
{
|
|
Status = STATUS_INVALID_PARAMETER;
|
|
break;
|
|
}
|
|
|
|
/* Create the escape sequence string */
|
|
l = sprintf(LocalBuffer, "\x1B[%dm\x1B[%dm", Data[1], Data[0]);
|
|
ASSERT((l + 1)*sizeof(UCHAR) < SAC_VTUTF8_COL_WIDTH);
|
|
ASSERT(LocalBuffer);
|
|
Tmp = LocalBuffer;
|
|
break;
|
|
|
|
/* Send the [#;#H (Cursor Position) sequence */
|
|
case SacAnsiSetPosition:
|
|
|
|
/* Allocate a small local buffer for it */
|
|
LocalBuffer = SacAllocatePool(SAC_VTUTF8_COL_WIDTH, GLOBAL_BLOCK_TAG);
|
|
CHECK_ALLOCATION(LocalBuffer);
|
|
|
|
/* Caller should have sent the position as two integers */
|
|
if (!(Data) || (Length != 8))
|
|
{
|
|
Status = STATUS_INVALID_PARAMETER;
|
|
break;
|
|
}
|
|
|
|
/* Create the escape sequence string */
|
|
l = sprintf(LocalBuffer, "\x1B[%d;%dH", Data[1] + 1, Data[0] + 1);
|
|
ASSERT((l + 1)*sizeof(UCHAR) < SAC_VTUTF8_COL_WIDTH);
|
|
ASSERT(LocalBuffer);
|
|
Tmp = LocalBuffer;
|
|
break;
|
|
|
|
/* Send the [0m sequence (Set Attribute 0) */
|
|
case SacAnsiClearAttributes:
|
|
Tmp = "\x1B[0m";
|
|
break;
|
|
|
|
/* Send the [7m sequence (Set Attribute 7) */
|
|
case SacAnsiSetInverseAttribute:
|
|
Tmp = "\x1B[7m";
|
|
break;
|
|
|
|
/* Send the [27m sequence (Set Attribute 27) */
|
|
case SacAnsiClearInverseAttribute:
|
|
Tmp = "\x1B[27m";
|
|
break;
|
|
|
|
/* Send the [5m sequence (Set Attribute 5) */
|
|
case SacAnsiSetBlinkAttribute:
|
|
Tmp = "\x1B[5m";
|
|
break;
|
|
|
|
/* Send the [25m sequence (Set Attribute 25) */
|
|
case SacAnsiClearBlinkAttribute:
|
|
Tmp = "\x1B[25m";
|
|
break;
|
|
|
|
/* Send the [1m sequence (Set Attribute 1) */
|
|
case SacAnsiSetBoldAttribute:
|
|
Tmp = "\x1B[1m";
|
|
break;
|
|
|
|
/* Send the [22m sequence (Set Attribute 22) */
|
|
case SacAnsiClearBoldAttribute:
|
|
Tmp = "\x1B[22m";
|
|
break;
|
|
|
|
/* We don't recognize it */
|
|
default:
|
|
Status = STATUS_INVALID_PARAMETER;
|
|
break;
|
|
}
|
|
|
|
/* Did everything work above? */
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* Go write out the sequence */
|
|
Status = ConMgrWriteData(Channel, Tmp, strlen(Tmp));
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* Now flush it */
|
|
Status = ConMgrFlushData(Channel);
|
|
}
|
|
}
|
|
|
|
/* Free the temporary buffer, if any, and return the status */
|
|
if (LocalBuffer) SacFreePool(LocalBuffer);
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VTUTF8ChannelProcessAttributes(IN PSAC_CHANNEL Channel,
|
|
IN UCHAR Attribute)
|
|
{
|
|
NTSTATUS Status;
|
|
CHECK_PARAMETER(Channel);
|
|
|
|
/* Set bold if needed */
|
|
Status = VTUTF8ChannelAnsiDispatch(Channel,
|
|
Attribute & SAC_CELL_FLAG_BOLD ?
|
|
SacAnsiSetBoldAttribute :
|
|
SacAnsiClearBoldAttribute,
|
|
NULL,
|
|
0);
|
|
if (!NT_SUCCESS(Status)) return Status;
|
|
|
|
/* Set blink if needed */
|
|
Status = VTUTF8ChannelAnsiDispatch(Channel,
|
|
Attribute & SAC_CELL_FLAG_BLINK ?
|
|
SacAnsiSetBlinkAttribute :
|
|
SacAnsiClearBlinkAttribute,
|
|
NULL,
|
|
0);
|
|
if (!NT_SUCCESS(Status)) return Status;
|
|
|
|
/* Set inverse if needed */
|
|
return VTUTF8ChannelAnsiDispatch(Channel,
|
|
Attribute & SAC_CELL_FLAG_INVERTED ?
|
|
SacAnsiSetInverseAttribute :
|
|
SacAnsiClearInverseAttribute,
|
|
NULL,
|
|
0);
|
|
}
|
|
|
|
//
|
|
// This function is the guts of the sequences that SAC supports.
|
|
//
|
|
// It is written to conform to the way that Microsoft's SAC driver interprets
|
|
// the ANSI standard. If you want to extend and/or "fix" it, please use a flag
|
|
// that can be set in the Registry to enable "extended" ANSI support or etc...
|
|
//
|
|
// Hermes, I'm looking at you, buddy.
|
|
//
|
|
ULONG
|
|
NTAPI
|
|
VTUTF8ChannelConsumeEscapeSequence(IN PSAC_CHANNEL Channel,
|
|
IN PWCHAR String)
|
|
{
|
|
ULONG Number, Number2, Number3, i, Action, Result;
|
|
PWCHAR Sequence;
|
|
PSAC_VTUTF8_SCREEN Screen;
|
|
ASSERT(String[0] == VT_ANSI_ESCAPE);
|
|
|
|
/* Microsoft's driver does this after the O(n) check below. Be smarter. */
|
|
if (String[1] != VT_ANSI_COMMAND) return 0;
|
|
|
|
/* Now that we know it's a valid command, look through the common cases */
|
|
for (i = 0; i < RTL_NUMBER_OF(SacStaticEscapeStrings); i++)
|
|
{
|
|
/* Check if an optimized sequence was detected */
|
|
if (!wcsncmp(String + 1,
|
|
SacStaticEscapeStrings[i].Sequence,
|
|
SacStaticEscapeStrings[i].Size))
|
|
{
|
|
/* Yep, return the right action, length, and set optionals to 1 */
|
|
Action = SacStaticEscapeStrings[i].Action;
|
|
Result = SacStaticEscapeStrings[i].Size + 1;
|
|
Number = Number2 = Number3 = 1;
|
|
goto ProcessString;
|
|
}
|
|
}
|
|
|
|
/* It's a more complex sequence, start parsing it */
|
|
Result = 0;
|
|
Sequence = String + 2;
|
|
|
|
/* First, check for the cursor sequences. This is useless due to above. */
|
|
switch (*Sequence)
|
|
{
|
|
case VT_ANSI_CURSOR_UP_CHAR:
|
|
Action = SacCursorUp;
|
|
goto ProcessString;
|
|
|
|
case VT_ANSI_CURSOR_DOWN_CHAR:
|
|
Action = SacCursorDown;
|
|
goto ProcessString;
|
|
|
|
case VT_ANSI_CURSOR_RIGHT_CHAR:
|
|
Action = SacCursorLeft; //bug
|
|
goto ProcessString;
|
|
|
|
case VT_ANSI_CURSOR_LEFT_CHAR:
|
|
Action = SacCursorRight; //bug
|
|
goto ProcessString;
|
|
|
|
case VT_ANSI_ERASE_LINE_CHAR:
|
|
Action = SacEraseEndOfLine;
|
|
goto ProcessString;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* This must be a sequence starting with ESC[# */
|
|
if (!VTUTF8ChannelScanForNumber(Sequence, &Number)) return 0;
|
|
while ((*Sequence >= L'0') && (*Sequence <= L'9')) Sequence++;
|
|
|
|
/* Check if this is ESC[#m */
|
|
if (*Sequence == VT_ANSI_SET_ATTRIBUTE_CHAR)
|
|
{
|
|
/* Some attribute is being set, go over the ones we support */
|
|
switch (Number)
|
|
{
|
|
/* Make the font standard */
|
|
case Normal:
|
|
Action = SacFontNormal;
|
|
break;
|
|
|
|
/* Make the font bold */
|
|
case Bold:
|
|
Action = SacFontBold;
|
|
break;
|
|
|
|
/* Make the font blink */
|
|
case SlowBlink:
|
|
Action = SacFontBlink;
|
|
break;
|
|
|
|
/* Make the font colors inverted */
|
|
case Inverse:
|
|
Action = SacFontInverse;
|
|
break;
|
|
|
|
/* Make the font standard intensity */
|
|
case BoldOff:
|
|
Action = SacFontBoldOff;
|
|
break;
|
|
|
|
/* Turn off blinking */
|
|
case BlinkOff:
|
|
Action = SacFontBlinkOff;
|
|
break;
|
|
|
|
/* Turn off inverted colors */
|
|
case InverseOff:
|
|
Action = SacFontInverseOff;
|
|
break;
|
|
|
|
/* Something else... */
|
|
default:
|
|
|
|
/* Is a background color being set? */
|
|
if ((Number < SetBackColorStart) || (Number > SetBackColorMax))
|
|
{
|
|
/* Nope... is it the foreground color? */
|
|
if ((Number < SetColorStart) || (Number > SetColorMax))
|
|
{
|
|
/* Nope. SAC expects no other attributes so bail out */
|
|
ASSERT(FALSE);
|
|
return 0;
|
|
}
|
|
|
|
/* Yep -- the number will tell us which */
|
|
Action = SacSetFontColor;
|
|
}
|
|
else
|
|
{
|
|
/* Yep -- the number will tell us which */
|
|
Action = SacSetBackgroundColor;
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* In all cases, we're done here */
|
|
goto ProcessString;
|
|
}
|
|
|
|
/* The only allowed possibility now is ESC[#;# */
|
|
if (*Sequence != VT_ANSI_SEPARATOR_CHAR) return 0;
|
|
Sequence++;
|
|
if (!VTUTF8ChannelScanForNumber(Sequence, &Number2)) return 0;
|
|
while ((*Sequence >= L'0') && (*Sequence <= L'9')) Sequence++;
|
|
|
|
/* There's two valid forms accepted at this point: ESC[#;#m and ESC[#;#H */
|
|
switch (*Sequence)
|
|
{
|
|
/* This is ESC[#;#m -- used to set both colors at once */
|
|
case VT_ANSI_SET_ATTRIBUTE_CHAR:
|
|
Action = SacSetColors;
|
|
goto ProcessString;
|
|
|
|
/* This is ESC[#;#H -- used to set the cursor position */
|
|
case VT_ANSI_CUP_CURSOR_CHAR:
|
|
Action = SacSetCursorPosition;
|
|
goto ProcessString;
|
|
|
|
/* Finally, this *could* be ESC[#;#; -- we'll keep parsing */
|
|
case VT_ANSI_SEPARATOR_CHAR:
|
|
Sequence++;
|
|
break;
|
|
|
|
/* Abandon anything else */
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
/* The SAC seems to accept a few more possibilities if a ';' follows... */
|
|
switch (*Sequence)
|
|
{
|
|
/* Both ESC[#;#;H and ESC[#;#;f are really the same command */
|
|
case VT_ANSI_CUP_CURSOR_CHAR:
|
|
case VT_ANSI_HVP_CURSOR_CHAR:
|
|
/* It's unclear why MS doesn't allow the HVP sequence on its own */
|
|
Action = SacSetCursorPosition;
|
|
goto ProcessString;
|
|
|
|
/* And this is the ESC[#;#;r command to set the scroll region... */
|
|
case VT_ANSI_SCROLL_CHAR:
|
|
/* Again, not clear why ESC[#;#r isn't supported */
|
|
Action = SacSetScrollRegion;
|
|
goto ProcessString;
|
|
|
|
/* Anything else must be ESC[#;#;# */
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* Get the last "#" */
|
|
if (!VTUTF8ChannelScanForNumber(Sequence, &Number3)) return 0;
|
|
while ((*Sequence >= L'0') && (*Sequence <= L'9')) Sequence++;
|
|
|
|
/* And now the only remaining possibility is ESC[#;#;#;m */
|
|
if (*Sequence == VT_ANSI_SET_ATTRIBUTE_CHAR)
|
|
{
|
|
/* Which sets both color and attributes in one command */
|
|
Action = SacSetColorsAndAttributes;
|
|
goto ProcessString;
|
|
}
|
|
|
|
/* No other sequences supported */
|
|
return 0;
|
|
|
|
ProcessString:
|
|
/* Unless we got here from the optimized path, calculate the length */
|
|
if (!Result) Result = Sequence - String + 1;
|
|
|
|
/* Get the current cell buffer */
|
|
Screen = (PSAC_VTUTF8_SCREEN)Channel->OBuffer;
|
|
VTUTF8ChannelAssertCursor(Channel);
|
|
|
|
/* Handle all the supported SAC ANSI commands */
|
|
switch (Action)
|
|
{
|
|
case SacCursorUp:
|
|
/* Check if we are scrolling too high */
|
|
if (Channel->CursorRow < Number)
|
|
{
|
|
/* Reset the row to the top */
|
|
Channel->CursorRow = 0;
|
|
}
|
|
else
|
|
{
|
|
/* We're fine -- scroll up by that much */
|
|
Channel->CursorRow -= Number;
|
|
}
|
|
|
|
/* All done */
|
|
VTUTF8ChannelAssertCursor(Channel);
|
|
break;
|
|
|
|
case SacCursorDown:
|
|
/* Check if we are scrolling too low */
|
|
if (Channel->CursorRow >= SAC_VTUTF8_ROW_HEIGHT)
|
|
{
|
|
/* Reset the row to the bottom */
|
|
Channel->CursorRow = SAC_VTUTF8_ROW_HEIGHT;
|
|
}
|
|
else
|
|
{
|
|
/* We're fine -- scroll down by that much */
|
|
Channel->CursorRow += Number;
|
|
}
|
|
|
|
/* All done */
|
|
VTUTF8ChannelAssertCursor(Channel);
|
|
break;
|
|
|
|
case SacCursorLeft:
|
|
/* Check if we're scrolling too much to the left */
|
|
if (Channel->CursorCol < Number)
|
|
{
|
|
/* Reset the column to the left-most margin */
|
|
Channel->CursorCol = 0;
|
|
}
|
|
else
|
|
{
|
|
/* We're fine -- scroll left by that much */
|
|
Channel->CursorCol -= Number;
|
|
}
|
|
|
|
/* All done */
|
|
VTUTF8ChannelAssertCursor(Channel);
|
|
break;
|
|
|
|
case SacCursorRight:
|
|
/* Check if we're scrolling too much to the right */
|
|
if (Channel->CursorCol >= SAC_VTUTF8_COL_WIDTH)
|
|
{
|
|
/* Reset the column to the right-most margin */
|
|
Channel->CursorCol = SAC_VTUTF8_COL_WIDTH;
|
|
}
|
|
else
|
|
{
|
|
/* We're fine -- scroll right by that much */
|
|
Channel->CursorCol += Number;
|
|
}
|
|
|
|
/* All done */
|
|
VTUTF8ChannelAssertCursor(Channel);
|
|
break;
|
|
|
|
case SacFontNormal:
|
|
/* Reset the cell attributes */
|
|
Channel->CellFlags = 0;
|
|
Channel->CellBackColor = SetBackColorBlack;
|
|
Channel->CellForeColor = SetColorWhite;
|
|
break;
|
|
|
|
case SacFontBlink:
|
|
/* Set the appropriate flag */
|
|
Channel->CellFlags |= SAC_CELL_FLAG_BLINK;
|
|
break;
|
|
|
|
case SacFontBlinkOff:
|
|
/* Clear the appropriate flag */
|
|
Channel->CellFlags &= ~SAC_CELL_FLAG_BLINK;
|
|
break;
|
|
|
|
case SacFontBold:
|
|
/* Set the appropriate flag */
|
|
Channel->CellFlags |= SAC_CELL_FLAG_BOLD;
|
|
break;
|
|
|
|
case SacFontBoldOff:
|
|
/* Clear the appropriate flag */
|
|
Channel->CellFlags &= ~SAC_CELL_FLAG_BOLD;
|
|
break;
|
|
|
|
case SacFontInverse:
|
|
/* Set the appropriate flag */
|
|
Channel->CellFlags |= SAC_CELL_FLAG_INVERTED;
|
|
break;
|
|
|
|
case SacFontInverseOff:
|
|
/* Clear the appropriate flag */
|
|
Channel->CellFlags &= ~SAC_CELL_FLAG_INVERTED;
|
|
break;
|
|
|
|
case SacEraseEndOfLine:
|
|
/* Loop all columns in this line past the current position */
|
|
for (i = Channel->CursorCol; i < SAC_VTUTF8_COL_WIDTH; i++)
|
|
{
|
|
/* Replace everything after the current position with blanks */
|
|
Screen->Cell[Channel->CursorRow][i].CellFlags = Channel->CellFlags;
|
|
Screen->Cell[Channel->CursorRow][i].CellBackColor = Channel->CellForeColor;
|
|
Screen->Cell[Channel->CursorRow][i].CellForeColor = Channel->CellBackColor;
|
|
Screen->Cell[Channel->CursorRow][i].Char = L' ';
|
|
}
|
|
break;
|
|
|
|
case SacEraseStartOfLine:
|
|
/* Loop all columns in this line, before the current position */
|
|
for (i = 0; i < (Channel->CursorCol + 1); i++)
|
|
{
|
|
/* Replace everything after the current position with blanks */
|
|
Screen->Cell[Channel->CursorRow][i].CellFlags = Channel->CellFlags;
|
|
Screen->Cell[Channel->CursorRow][i].CellBackColor = Channel->CellForeColor;
|
|
Screen->Cell[Channel->CursorRow][i].CellForeColor = Channel->CellBackColor;
|
|
Screen->Cell[Channel->CursorRow][i].Char = L' ';
|
|
}
|
|
break;
|
|
|
|
case SacEraseLine:
|
|
/* Loop all the columns in this line */
|
|
for (i = 0; i < SAC_VTUTF8_COL_WIDTH; i++)
|
|
{
|
|
/* Replace them all with blanks */
|
|
Screen->Cell[Channel->CursorRow][i].CellFlags = Channel->CellFlags;
|
|
Screen->Cell[Channel->CursorRow][i].CellBackColor = Channel->CellForeColor;
|
|
Screen->Cell[Channel->CursorRow][i].CellForeColor = Channel->CellBackColor;
|
|
Screen->Cell[Channel->CursorRow][i].Char = L' ';
|
|
}
|
|
break;
|
|
|
|
case SacEraseEndOfScreen:
|
|
ASSERT(FALSE); // todo
|
|
break;
|
|
|
|
case SacEraseStartOfScreen:
|
|
ASSERT(FALSE); // todo
|
|
break;
|
|
|
|
case SacEraseScreen:
|
|
ASSERT(FALSE); // todo
|
|
break;
|
|
|
|
case SacSetCursorPosition:
|
|
ASSERT(FALSE); // todo
|
|
break;
|
|
|
|
case SacSetScrollRegion:
|
|
ASSERT(FALSE); // todo
|
|
break;
|
|
|
|
case SacSetColors:
|
|
/* Set the cell colors */
|
|
Channel->CellForeColor = Number;
|
|
Channel->CellBackColor = Number2;
|
|
break;
|
|
|
|
case SacSetBackgroundColor:
|
|
/* Set the cell back color */
|
|
Channel->CellBackColor = Number;
|
|
break;
|
|
|
|
case SacSetFontColor:
|
|
/* Set the cell text color */
|
|
Channel->CellForeColor = Number;
|
|
break;
|
|
|
|
case SacSetColorsAndAttributes:
|
|
/* Set the cell flag and colors */
|
|
Channel->CellFlags = Number;
|
|
Channel->CellForeColor = Number2;
|
|
Channel->CellBackColor = Number3;
|
|
break;
|
|
|
|
default:
|
|
/* Unknown, do nothing */
|
|
break;
|
|
}
|
|
|
|
/* Return the length of the sequence */
|
|
return Result;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VTUTF8ChannelOInit(IN PSAC_CHANNEL Channel)
|
|
{
|
|
PSAC_VTUTF8_SCREEN Screen;
|
|
ULONG R, C;
|
|
CHECK_PARAMETER(Channel);
|
|
|
|
/* Set the current channel cell parameters */
|
|
Channel->CellFlags = 0;
|
|
Channel->CellBackColor = SetBackColorBlack;
|
|
Channel->CellForeColor = SetColorWhite;
|
|
|
|
/* Set the cell buffer position */
|
|
Screen = (PSAC_VTUTF8_SCREEN)Channel->OBuffer;
|
|
|
|
/* Loop the output buffer height by width */
|
|
for (R = 0; R < SAC_VTUTF8_ROW_HEIGHT; R++)
|
|
{
|
|
for (C = 0; C < SAC_VTUTF8_COL_WIDTH; C++)
|
|
{
|
|
/* For every character, set the defaults */
|
|
Screen->Cell[R][C].Char = L' ';
|
|
Screen->Cell[R][C].CellBackColor = SetBackColorBlack;
|
|
Screen->Cell[R][C].CellForeColor = SetColorWhite;
|
|
}
|
|
}
|
|
|
|
/* All done */
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VTUTF8ChannelCreate(IN PSAC_CHANNEL Channel)
|
|
{
|
|
NTSTATUS Status;
|
|
CHECK_PARAMETER(Channel);
|
|
|
|
/* Allocate the output buffer */
|
|
Channel->OBuffer = SacAllocatePool(SAC_VTUTF8_OBUFFER_SIZE, GLOBAL_BLOCK_TAG);
|
|
CHECK_ALLOCATION(Channel->OBuffer);
|
|
|
|
/* Allocate the input buffer */
|
|
Channel->IBuffer = SacAllocatePool(SAC_VTUTF8_IBUFFER_SIZE, GLOBAL_BLOCK_TAG);
|
|
CHECK_ALLOCATION(Channel->IBuffer);
|
|
|
|
/* Initialize the output stream */
|
|
Status = VTUTF8ChannelOInit(Channel);
|
|
if (NT_SUCCESS(Status)) return Status;
|
|
|
|
/* Reset all flags and return success */
|
|
_InterlockedExchange(&Channel->ChannelHasNewOBufferData, 0);
|
|
_InterlockedExchange(&Channel->ChannelHasNewIBufferData, 0);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VTUTF8ChannelDestroy(IN PSAC_CHANNEL Channel)
|
|
{
|
|
CHECK_PARAMETER(Channel);
|
|
|
|
/* Free the buffer and then destroy the channel */
|
|
if (Channel->OBuffer) SacFreePool(Channel->OBuffer);
|
|
if (Channel->IBuffer) SacFreePool(Channel->IBuffer);
|
|
return ChannelDestroy(Channel);
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VTUTF8ChannelORead(IN PSAC_CHANNEL Channel,
|
|
IN PCHAR Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG ByteCount)
|
|
{
|
|
ASSERT(FALSE);
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VTUTF8ChannelOFlush(IN PSAC_CHANNEL Channel)
|
|
{
|
|
NTSTATUS Status;
|
|
PSAC_VTUTF8_SCREEN Screen;
|
|
INT Color[2], Position[2];
|
|
ULONG Utf8ProcessedCount, Utf8Count, R, C, ForeColor, BackColor, Attribute;
|
|
PWCHAR TmpBuffer;
|
|
BOOLEAN Overflow = FALSE;
|
|
CHECK_PARAMETER(Channel);
|
|
|
|
/* Set the cell buffer position */
|
|
Screen = (PSAC_VTUTF8_SCREEN)Channel->OBuffer;
|
|
|
|
/* Allocate a temporary buffer */
|
|
TmpBuffer = SacAllocatePool(40, GLOBAL_BLOCK_TAG);
|
|
if (!TmpBuffer)
|
|
{
|
|
Status = STATUS_NO_MEMORY;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* First, clear the screen */
|
|
Status = VTUTF8ChannelAnsiDispatch(Channel,
|
|
SacAnsiClearScreen,
|
|
NULL,
|
|
0);
|
|
if (!NT_SUCCESS(Status)) goto Quickie;
|
|
|
|
/* Next, reset the cursor position */
|
|
Position[1] = 0;
|
|
Position[0] = 0;
|
|
Status = VTUTF8ChannelAnsiDispatch(Channel,
|
|
SacAnsiSetPosition,
|
|
Position,
|
|
sizeof(Position));
|
|
if (!NT_SUCCESS(Status)) goto Quickie;
|
|
|
|
/* Finally, reset the attributes */
|
|
Status = VTUTF8ChannelAnsiDispatch(Channel,
|
|
SacAnsiClearAttributes,
|
|
NULL,
|
|
0);
|
|
if (!NT_SUCCESS(Status)) goto Quickie;
|
|
|
|
/* Now set the current cell attributes */
|
|
Attribute = Channel->CellFlags;
|
|
Status = VTUTF8ChannelProcessAttributes(Channel, Attribute);
|
|
if (!NT_SUCCESS(Status)) goto Quickie;
|
|
|
|
/* And set the current cell colors */
|
|
ForeColor = Channel->CellForeColor;
|
|
BackColor = Channel->CellBackColor;
|
|
Color[1] = BackColor;
|
|
Color[0] = ForeColor;
|
|
Status = VTUTF8ChannelAnsiDispatch(Channel,
|
|
SacAnsiSetColors,
|
|
Color,
|
|
sizeof(Color));
|
|
if (!NT_SUCCESS(Status)) goto Quickie;
|
|
|
|
/* Now loop all the characters in the cell buffer */
|
|
for (R = 0; R < SAC_VTUTF8_ROW_HEIGHT; R++)
|
|
{
|
|
/* Across every row */
|
|
for (C = 0; C < SAC_VTUTF8_COL_WIDTH; C++)
|
|
{
|
|
/* Check if there's been a change in colors */
|
|
if ((Screen->Cell[R][C].CellBackColor != BackColor) ||
|
|
(Screen->Cell[R][C].CellForeColor != ForeColor))
|
|
{
|
|
/* New colors are being drawn -- are we also on a new row now? */
|
|
if (Overflow)
|
|
{
|
|
/* Reposition the cursor correctly */
|
|
Position[1] = R;
|
|
Position[0] = C;
|
|
Status = VTUTF8ChannelAnsiDispatch(Channel,
|
|
SacAnsiSetPosition,
|
|
Position,
|
|
sizeof(Position));
|
|
if (!NT_SUCCESS(Status)) goto Quickie;
|
|
Overflow = FALSE;
|
|
}
|
|
|
|
/* Cache the new colors */
|
|
ForeColor = Screen->Cell[R][C].CellForeColor;
|
|
BackColor = Screen->Cell[R][C].CellBackColor;
|
|
|
|
/* Set them on the screen */
|
|
Color[1] = BackColor;
|
|
Color[0] = ForeColor;
|
|
Status = VTUTF8ChannelAnsiDispatch(Channel,
|
|
SacAnsiSetColors,
|
|
Color,
|
|
sizeof(Color));
|
|
if (!NT_SUCCESS(Status)) goto Quickie;
|
|
}
|
|
|
|
/* Check if there's been a change in attributes */
|
|
if (Screen->Cell[R][C].CellFlags != Attribute)
|
|
{
|
|
/* Yep! Are we also on a new row now? */
|
|
if (Overflow)
|
|
{
|
|
/* Reposition the cursor correctly */
|
|
Position[1] = R;
|
|
Position[0] = C;
|
|
Status = VTUTF8ChannelAnsiDispatch(Channel,
|
|
SacAnsiSetPosition,
|
|
Position,
|
|
sizeof(Position));
|
|
if (!NT_SUCCESS(Status)) goto Quickie;
|
|
Overflow = FALSE;
|
|
}
|
|
|
|
/* Set the new attributes on screen */
|
|
Attribute = Screen->Cell[R][C].CellFlags;
|
|
Status = VTUTF8ChannelProcessAttributes(Channel, Attribute);
|
|
if (!NT_SUCCESS(Status)) goto Quickie;
|
|
}
|
|
|
|
/* Time to write the character -- are we on a new row now? */
|
|
if (Overflow)
|
|
{
|
|
/* Reposition the cursor correctly */
|
|
Position[1] = R;
|
|
Position[0] = C;
|
|
Status = VTUTF8ChannelAnsiDispatch(Channel,
|
|
SacAnsiSetPosition,
|
|
Position,
|
|
sizeof(Position));
|
|
if (!NT_SUCCESS(Status)) goto Quickie;
|
|
Overflow = FALSE;
|
|
}
|
|
|
|
/* Write the character into our temporary buffer */
|
|
*TmpBuffer = Screen->Cell[R][C].Char;
|
|
TmpBuffer[1] = UNICODE_NULL;
|
|
|
|
/* Convert it to UTF-8 */
|
|
if (!SacTranslateUnicodeToUtf8(TmpBuffer,
|
|
1,
|
|
Utf8ConversionBuffer,
|
|
Utf8ConversionBufferSize,
|
|
&Utf8Count,
|
|
&Utf8ProcessedCount))
|
|
{
|
|
/* Bail out if this failed */
|
|
Status = STATUS_UNSUCCESSFUL;
|
|
goto Quickie;
|
|
}
|
|
|
|
/* Make sure we have a remaining valid character */
|
|
if (Utf8Count)
|
|
{
|
|
/* Write it out on the wire */
|
|
Status = ConMgrWriteData(Channel, Utf8ConversionBuffer, Utf8Count);
|
|
if (!NT_SUCCESS(Status)) goto Quickie;
|
|
}
|
|
}
|
|
|
|
/* All the characters on the row are done, indicate we need a reset */
|
|
Overflow = TRUE;
|
|
}
|
|
|
|
/* Everything is done, set the position one last time */
|
|
Position[1] = Channel->CursorRow;
|
|
Position[0] = Channel->CursorCol;
|
|
Status = VTUTF8ChannelAnsiDispatch(Channel,
|
|
SacAnsiSetPosition,
|
|
Position,
|
|
sizeof(Position));
|
|
if (!NT_SUCCESS(Status)) goto Quickie;
|
|
|
|
/* Set the current attribute one last time */
|
|
Status = VTUTF8ChannelProcessAttributes(Channel, Channel->CellFlags);
|
|
if (!NT_SUCCESS(Status)) goto Quickie;
|
|
|
|
/* Set the current colors one last time */
|
|
Color[1] = Channel->CellBackColor;
|
|
Color[0] = Channel->CellForeColor;
|
|
Status = VTUTF8ChannelAnsiDispatch(Channel,
|
|
SacAnsiSetColors,
|
|
Color,
|
|
sizeof(Color));
|
|
if (!NT_SUCCESS(Status)) goto Quickie;
|
|
|
|
/* Flush all the data out on the wire */
|
|
Status = ConMgrFlushData(Channel);
|
|
|
|
Quickie:
|
|
/* We're done, free the temporary buffer */
|
|
if (TmpBuffer) SacFreePool(TmpBuffer);
|
|
|
|
/* Indicate that all new data has been flushed now */
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
_InterlockedExchange(&Channel->ChannelHasNewOBufferData, 0);
|
|
}
|
|
|
|
/* Return the result */
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VTUTF8ChannelOWrite2(IN PSAC_CHANNEL Channel,
|
|
IN PWCHAR String,
|
|
IN ULONG Size)
|
|
{
|
|
PSAC_VTUTF8_SCREEN Screen;
|
|
ULONG i, EscapeSize, R, C;
|
|
PWSTR pwch;
|
|
CHECK_PARAMETER1(Channel);
|
|
CHECK_PARAMETER2(String);
|
|
VTUTF8ChannelAssertCursor(Channel);
|
|
|
|
/* Loop every character */
|
|
Screen = (PSAC_VTUTF8_SCREEN)Channel->OBuffer;
|
|
for (i = 0; i < Size; i++)
|
|
{
|
|
/* Check what the character is */
|
|
pwch = &String[i];
|
|
switch (*pwch)
|
|
{
|
|
/* It's an escape sequence... */
|
|
case L'\x1B':
|
|
|
|
/* Send it to the parser, see how long the sequence was */
|
|
EscapeSize = VTUTF8ChannelConsumeEscapeSequence(Channel, pwch);
|
|
if (EscapeSize)
|
|
{
|
|
/* Consume that many characters for next time*/
|
|
i += EscapeSize - 1;
|
|
}
|
|
else
|
|
{
|
|
/* Invalid escape sequence, skip just the ESC character */
|
|
i++;
|
|
}
|
|
|
|
/* Keep going*/
|
|
break;
|
|
|
|
/* It's a line feed */
|
|
case L'\n':
|
|
|
|
/* Simply reset the column to zero on the current line */
|
|
Channel->CursorCol = 0;
|
|
break;
|
|
|
|
/* It's a carriage feed */
|
|
case L'\r':
|
|
|
|
/* Move to the next row */
|
|
Channel->CursorRow++;
|
|
|
|
/* Check if we hit the last row on the screen */
|
|
if (Channel->CursorRow >= SAC_VTUTF8_ROW_HEIGHT)
|
|
{
|
|
/* Go over every row before the last one */
|
|
for (R = 0; R < (SAC_VTUTF8_ROW_HEIGHT - 1); R++)
|
|
{
|
|
/* Sanity check, since we always copy one row below */
|
|
ASSERT((R + 1) < SAC_VTUTF8_ROW_HEIGHT);
|
|
|
|
/* Loop every character on the row */
|
|
for (C = 0; C < SAC_VTUTF8_COL_WIDTH; C++)
|
|
{
|
|
/* And replace it with one from the row below */
|
|
Screen->Cell[R][C] = Screen->Cell[R + 1][C];
|
|
}
|
|
}
|
|
|
|
/* Now we're left with the before-last row, zero it out */
|
|
ASSERT(R == (SAC_VTUTF8_ROW_HEIGHT - 1));
|
|
RtlZeroMemory(&Screen->Cell[R], sizeof(Screen->Cell[R]));
|
|
|
|
/* Reset the row back by one */
|
|
Channel->CursorRow--;
|
|
VTUTF8ChannelAssertCursor(Channel);
|
|
}
|
|
break;
|
|
|
|
/* It's a TAB character */
|
|
case L'\t':
|
|
|
|
/* Loop the remaining characters until a multiple of 4 */
|
|
VTUTF8ChannelAssertCursor(Channel);
|
|
for (C = (4 - Channel->CursorCol % 4); C; C--)
|
|
{
|
|
/* Fill each remaining character with a space */
|
|
VTUTF8ChannelAssertCursor(Channel);
|
|
Screen->Cell[Channel->CursorRow][Channel->CursorCol].CellFlags = Channel->CellFlags;
|
|
Screen->Cell[Channel->CursorRow][Channel->CursorCol].CellBackColor = Channel->CellBackColor;
|
|
Screen->Cell[Channel->CursorRow][Channel->CursorCol].CellForeColor = Channel->CellForeColor;
|
|
Screen->Cell[Channel->CursorRow][Channel->CursorCol].Char = L' ';
|
|
|
|
/* Move to the next character position, but don't overflow */
|
|
Channel->CursorCol++;
|
|
if (Channel->CursorCol >= SAC_VTUTF8_COL_WIDTH)
|
|
{
|
|
Channel->CursorCol = SAC_VTUTF8_COL_WIDTH - 1;
|
|
}
|
|
}
|
|
|
|
/* All done, move to the next one */
|
|
VTUTF8ChannelAssertCursor(Channel);
|
|
break;
|
|
|
|
/* It's a backspace or delete character */
|
|
case L'\b':
|
|
case L'\x7F':
|
|
|
|
/* Move back one character, unless we had nothing typed */
|
|
if (Channel->CursorCol) Channel->CursorCol--;
|
|
VTUTF8ChannelAssertCursor(Channel);
|
|
break;
|
|
|
|
/* It's some other character */
|
|
default:
|
|
|
|
/* Is it non-printable? Ignore it and keep parsing */
|
|
if (*pwch < L' ') continue;
|
|
|
|
/* Otherwise, print it out with the current attributes */
|
|
VTUTF8ChannelAssertCursor(Channel);
|
|
Screen->Cell[Channel->CursorRow][Channel->CursorCol].CellFlags = Channel->CellFlags;
|
|
Screen->Cell[Channel->CursorRow][Channel->CursorCol].CellBackColor = Channel->CellBackColor;
|
|
Screen->Cell[Channel->CursorRow][Channel->CursorCol].CellForeColor = Channel->CellForeColor;
|
|
Screen->Cell[Channel->CursorRow][Channel->CursorCol].Char = *pwch;
|
|
|
|
/* Move forward one character, but make sure not to overflow */
|
|
Channel->CursorCol++;
|
|
if (Channel->CursorCol == SAC_VTUTF8_COL_WIDTH)
|
|
{
|
|
Channel->CursorCol = SAC_VTUTF8_COL_WIDTH - 1;
|
|
}
|
|
|
|
/* All done, move to the next one */
|
|
VTUTF8ChannelAssertCursor(Channel);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Parsing of the input string completed -- string was written */
|
|
VTUTF8ChannelAssertCursor(Channel);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VTUTF8ChannelOEcho(IN PSAC_CHANNEL Channel,
|
|
IN PCHAR String,
|
|
IN ULONG Size)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PWSTR pwch;
|
|
ULONG i, k, TranslatedCount, UTF8TranslationSize;
|
|
BOOLEAN Result;
|
|
CHECK_PARAMETER1(Channel);
|
|
CHECK_PARAMETER2(String);
|
|
|
|
/* Return success if there's nothing to echo */
|
|
if (!(Size / sizeof(WCHAR))) return Status;
|
|
|
|
/* Start with the input string */
|
|
pwch = (PWCHAR)String;
|
|
|
|
/* First, figure out how much is outside of the block length alignment */
|
|
k = (Size / sizeof(WCHAR)) % MAX_UTF8_ENCODE_BLOCK_LENGTH;
|
|
if (k)
|
|
{
|
|
/* Translate the misaligned portion */
|
|
Result = SacTranslateUnicodeToUtf8(pwch,
|
|
k,
|
|
Utf8ConversionBuffer,
|
|
Utf8ConversionBufferSize,
|
|
&UTF8TranslationSize,
|
|
&TranslatedCount);
|
|
ASSERT(k == TranslatedCount);
|
|
if (!Result)
|
|
{
|
|
/* If we couldn't translate, write failure to break out below */
|
|
Status = STATUS_UNSUCCESSFUL;
|
|
}
|
|
else
|
|
{
|
|
/* Write the misaligned portion into the buffer */
|
|
Status = ConMgrWriteData(Channel,
|
|
Utf8ConversionBuffer,
|
|
UTF8TranslationSize);
|
|
}
|
|
|
|
/* If translation or write failed, bail out */
|
|
if (!NT_SUCCESS(Status)) goto Return;
|
|
}
|
|
|
|
/* Push the string to its new location (this could be a noop if aligned) */
|
|
pwch += k;
|
|
|
|
/* Now figure out how many aligned blocks we have, and loop each one */
|
|
k = (Size / sizeof(WCHAR)) / MAX_UTF8_ENCODE_BLOCK_LENGTH;
|
|
for (i = 0; i < k; i++)
|
|
{
|
|
/* Translate the aligned block */
|
|
Result = SacTranslateUnicodeToUtf8(pwch,
|
|
MAX_UTF8_ENCODE_BLOCK_LENGTH,
|
|
Utf8ConversionBuffer,
|
|
Utf8ConversionBufferSize,
|
|
&UTF8TranslationSize,
|
|
&TranslatedCount);
|
|
ASSERT(MAX_UTF8_ENCODE_BLOCK_LENGTH == TranslatedCount);
|
|
ASSERT(UTF8TranslationSize > 0);
|
|
if (!Result)
|
|
{
|
|
/* Set failure here, we'll break out below */
|
|
Status = STATUS_UNSUCCESSFUL;
|
|
}
|
|
else
|
|
{
|
|
/* Move the string location to the next aligned block */
|
|
pwch += MAX_UTF8_ENCODE_BLOCK_LENGTH;
|
|
|
|
/* Write the aligned block into the buffer */
|
|
Status = ConMgrWriteData(Channel,
|
|
Utf8ConversionBuffer,
|
|
UTF8TranslationSize);
|
|
}
|
|
|
|
/* If translation or write failed, bail out */
|
|
if (!NT_SUCCESS(Status)) break;
|
|
}
|
|
|
|
Return:
|
|
ASSERT(pwch == (PWSTR)(String + Size));
|
|
if (NT_SUCCESS(Status)) Status = ConMgrFlushData(Channel);
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VTUTF8ChannelOWrite(IN PSAC_CHANNEL Channel,
|
|
IN PCHAR String,
|
|
IN ULONG Length)
|
|
{
|
|
NTSTATUS Status;
|
|
CHECK_PARAMETER1(Channel);
|
|
CHECK_PARAMETER2(String);
|
|
|
|
/* Call the lower level function */
|
|
Status = VTUTF8ChannelOWrite2(Channel, (PWCHAR)String, Length / sizeof(WCHAR));
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* Is the channel enabled for output? */
|
|
if ((ConMgrIsWriteEnabled(Channel)) && (Channel->WriteEnabled))
|
|
{
|
|
/* Go ahead and output it */
|
|
Status = VTUTF8ChannelOEcho(Channel, String, Length);
|
|
}
|
|
else
|
|
{
|
|
/* Otherwise, just remember that we have new data */
|
|
_InterlockedExchange(&Channel->ChannelHasNewOBufferData, 1);
|
|
}
|
|
}
|
|
|
|
/* We're done */
|
|
return Status;
|
|
}
|
|
|
|
ULONG
|
|
NTAPI
|
|
VTUTF8ChannelGetIBufferIndex(IN PSAC_CHANNEL Channel)
|
|
{
|
|
ASSERT(Channel);
|
|
ASSERT((Channel->IBufferIndex % sizeof(WCHAR)) == 0);
|
|
ASSERT(Channel->IBufferIndex < SAC_VTUTF8_IBUFFER_SIZE);
|
|
|
|
/* Return the current buffer index */
|
|
return Channel->IBufferIndex;
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
VTUTF8ChannelSetIBufferIndex(IN PSAC_CHANNEL Channel,
|
|
IN ULONG BufferIndex)
|
|
{
|
|
NTSTATUS Status;
|
|
ASSERT(Channel);
|
|
ASSERT((Channel->IBufferIndex % sizeof(WCHAR)) == 0);
|
|
ASSERT(Channel->IBufferIndex < SAC_VTUTF8_IBUFFER_SIZE);
|
|
|
|
/* Set the new index, and if it's not zero, it means we have data */
|
|
Channel->IBufferIndex = BufferIndex;
|
|
_InterlockedExchange(&Channel->ChannelHasNewIBufferData, BufferIndex != 0);
|
|
|
|
/* If we have new data, and an event has been registered... */
|
|
if (!(Channel->IBufferIndex) &&
|
|
(Channel->Flags & SAC_CHANNEL_FLAG_HAS_NEW_DATA_EVENT))
|
|
{
|
|
/* Go ahead and signal it */
|
|
ChannelClearEvent(Channel, HasNewDataEvent);
|
|
UNREFERENCED_PARAMETER(Status);
|
|
}
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VTUTF8ChannelIRead(IN PSAC_CHANNEL Channel,
|
|
IN PCHAR Buffer,
|
|
IN ULONG BufferSize,
|
|
IN PULONG ReturnBufferSize)
|
|
{
|
|
ULONG CopyChars, ReadLength;
|
|
CHECK_PARAMETER1(Channel);
|
|
CHECK_PARAMETER2(Buffer);
|
|
CHECK_PARAMETER_WITH_STATUS(BufferSize > 0, STATUS_INVALID_BUFFER_SIZE);
|
|
|
|
/* Assume failure */
|
|
*ReturnBufferSize = 0;
|
|
|
|
/* Check how many bytes are in the buffer */
|
|
if (Channel->ChannelInputBufferLength(Channel) == 0)
|
|
{
|
|
/* Apparently nothing. Make sure the flag indicates so too */
|
|
ASSERT(ChannelHasNewIBufferData(Channel) == FALSE);
|
|
}
|
|
else
|
|
{
|
|
/* Use the smallest number of bytes either in the buffer or requested */
|
|
ReadLength = min(Channel->ChannelInputBufferLength(Channel) * sizeof(WCHAR),
|
|
BufferSize);
|
|
|
|
/* Do some cheezy buffer alignment */
|
|
CopyChars = ReadLength / sizeof(WCHAR);
|
|
ReadLength = CopyChars * sizeof(WCHAR);
|
|
ASSERT(CopyChars <= Channel->ChannelInputBufferLength(Channel));
|
|
|
|
/* Copy them into the caller's buffer */
|
|
RtlCopyMemory(Buffer, Channel->IBuffer, ReadLength);
|
|
|
|
/* Update the channel's index past the copied (read) bytes */
|
|
VTUTF8ChannelSetIBufferIndex(Channel,
|
|
VTUTF8ChannelGetIBufferIndex(Channel) - ReadLength);
|
|
|
|
/* Are there still bytes that haven't been read yet? */
|
|
if (Channel->ChannelInputBufferLength(Channel))
|
|
{
|
|
/* Shift them up in the buffer */
|
|
RtlMoveMemory(Channel->IBuffer,
|
|
&Channel->IBuffer[ReadLength],
|
|
Channel->ChannelInputBufferLength(Channel) *
|
|
sizeof(WCHAR));
|
|
}
|
|
|
|
/* Return the number of bytes we actually copied */
|
|
*ReturnBufferSize = ReadLength;
|
|
}
|
|
|
|
/* Return success */
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VTUTF8ChannelIBufferIsFull(IN PSAC_CHANNEL Channel,
|
|
OUT PBOOLEAN BufferStatus)
|
|
{
|
|
CHECK_PARAMETER1(Channel);
|
|
|
|
/* If the index is beyond the length, the buffer must be full */
|
|
*BufferStatus = VTUTF8ChannelGetIBufferIndex(Channel) > SAC_VTUTF8_IBUFFER_SIZE;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
ULONG
|
|
NTAPI
|
|
VTUTF8ChannelIBufferLength(IN PSAC_CHANNEL Channel)
|
|
{
|
|
ASSERT(Channel);
|
|
|
|
/* The index is the length, so divide by two to get character count */
|
|
return VTUTF8ChannelGetIBufferIndex(Channel) / sizeof(WCHAR);
|
|
}
|
|
|
|
WCHAR
|
|
NTAPI
|
|
VTUTF8ChannelIReadLast(IN PSAC_CHANNEL Channel)
|
|
{
|
|
PWCHAR LastCharLocation;
|
|
WCHAR LastChar = 0;
|
|
ASSERT(Channel);
|
|
|
|
/* Check if there's anything to read in the buffer */
|
|
if (Channel->ChannelInputBufferLength(Channel))
|
|
{
|
|
/* Go back one character */
|
|
VTUTF8ChannelSetIBufferIndex(Channel,
|
|
VTUTF8ChannelGetIBufferIndex(Channel) -
|
|
sizeof(WCHAR));
|
|
|
|
/* Read it, and clear its current value */
|
|
LastCharLocation = (PWCHAR)&Channel->IBuffer[VTUTF8ChannelGetIBufferIndex(Channel)];
|
|
LastChar = *LastCharLocation;
|
|
*LastCharLocation = UNICODE_NULL;
|
|
}
|
|
|
|
/* Return the last character */
|
|
return LastChar;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VTUTF8ChannelIWrite(IN PSAC_CHANNEL Channel,
|
|
IN PCHAR Buffer,
|
|
IN ULONG BufferSize)
|
|
{
|
|
NTSTATUS Status;
|
|
BOOLEAN IsFull;
|
|
ULONG Index, i;
|
|
CHECK_PARAMETER1(Channel);
|
|
CHECK_PARAMETER2(Buffer);
|
|
CHECK_PARAMETER_WITH_STATUS(BufferSize > 0, STATUS_INVALID_BUFFER_SIZE);
|
|
|
|
/* First, check if the input buffer still has space */
|
|
Status = VTUTF8ChannelIBufferIsFull(Channel, &IsFull);
|
|
if (!NT_SUCCESS(Status)) return Status;
|
|
if (IsFull) return STATUS_UNSUCCESSFUL;
|
|
|
|
/* Get the current buffer index */
|
|
Index = VTUTF8ChannelGetIBufferIndex(Channel);
|
|
if ((SAC_VTUTF8_IBUFFER_SIZE - Index) < BufferSize)
|
|
{
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
/* Copy the new data */
|
|
for (i = 0; i < BufferSize; i++)
|
|
{
|
|
/* Convert the character */
|
|
if (SacTranslateUtf8ToUnicode(Buffer[i],
|
|
IncomingUtf8ConversionBuffer,
|
|
&IncomingUnicodeValue))
|
|
{
|
|
/* Write it into the buffer */
|
|
*(PWCHAR)&Channel->IBuffer[VTUTF8ChannelGetIBufferIndex(Channel)] =
|
|
IncomingUnicodeValue;
|
|
|
|
/* Update the index */
|
|
Index = VTUTF8ChannelGetIBufferIndex(Channel);
|
|
VTUTF8ChannelSetIBufferIndex(Channel, Index + sizeof(WCHAR));
|
|
}
|
|
}
|
|
|
|
/* Signal the event, if one was set */
|
|
if (Channel->Flags & SAC_CHANNEL_FLAG_HAS_NEW_DATA_EVENT)
|
|
{
|
|
ChannelSetEvent(Channel, HasNewDataEvent);
|
|
}
|
|
|
|
/* All done */
|
|
return STATUS_SUCCESS;
|
|
}
|