3751 lines
102 KiB
C
3751 lines
102 KiB
C
/*
|
|
ANSI.c - ANSI escape sequence console driver.
|
|
|
|
Jason Hood, 21 & 22 October, 2005.
|
|
|
|
Derived from ANSI.xs by Jean-Louis Morel, from his Perl package
|
|
Win32::Console::ANSI. I removed the codepage conversion ("\e(") and added
|
|
WriteConsole hooking.
|
|
|
|
v1.01, 11 & 12 March, 2006:
|
|
disable when console has disabled processed output;
|
|
\e[5m (blink) is the same as \e[4m (underline);
|
|
do not conceal control characters (0 to 31);
|
|
\e[m will restore original color.
|
|
|
|
v1.10, 22 February, 2009:
|
|
fix MyWriteConsoleW for strings longer than the buffer;
|
|
initialise attributes to current;
|
|
hook into child processes.
|
|
|
|
v1.11, 28 February, 2009:
|
|
fix hooking into child processes (only do console executables).
|
|
|
|
v1.12, 9 March, 2009:
|
|
really fix hooking (I didn't realise MinGW didn't generate relocations).
|
|
|
|
v1.13, 21 & 27 March, 2009:
|
|
alternate injection method, to work with DEP;
|
|
use Unicode and the current output code page (not OEMCP).
|
|
|
|
v1.14, 3 April, 2009:
|
|
fix test for empty import section.
|
|
|
|
v1.15, 17 May, 2009:
|
|
properly update lpNumberOfCharsWritten in MyWriteConsoleA.
|
|
|
|
v1.20, 26 & 29 May, 17 to 21 June, 2009:
|
|
create an ANSICON environment variable;
|
|
hook GetEnvironmentVariable to create ANSICON dynamically;
|
|
use another injection method.
|
|
|
|
v1.22, 5 October, 2009:
|
|
hook LoadLibrary to intercept the newly loaded functions.
|
|
|
|
v1.23, 11 November, 2009:
|
|
unload gracefully;
|
|
conceal characters by making foreground same as background;
|
|
reverse the bold/underline attributes, too.
|
|
|
|
v1.25, 15, 20 & 21 July, 2010:
|
|
hook LoadLibraryEx (now cscript works);
|
|
Win7 support.
|
|
|
|
v1.30, 3 August to 7 September, 2010:
|
|
x64 support.
|
|
|
|
v1.31, 13 & 19 November, 2010:
|
|
fix multibyte conversion problems.
|
|
|
|
v1.32, 4 to 22 December, 2010:
|
|
test for lpNumberOfCharsWritten/lpNumberOfBytesWritten being NULL;
|
|
recognise DSR and xterm window title;
|
|
ignore sequences starting with \e[? & \e[>;
|
|
close the handles opened by CreateProcess.
|
|
|
|
v1.40, 25 & 26 February, 1 March, 2011:
|
|
hook GetProcAddress, addresses issues with .NET (work with PowerShell);
|
|
implement SO & SI to use the DEC Special Graphics Character Set (enables
|
|
line drawing via ASCII); ignore \e(X & \e)X (where X is any character);
|
|
add \e[?25h & \e[?25l to show/hide the cursor (DECTCEM).
|
|
|
|
v1.50, 7 to 14 December, 2011:
|
|
added dynamic environment variable ANSICON_VER to return version;
|
|
read ANSICON_EXC environment variable to exclude selected modules;
|
|
read ANSICON_GUI environment variable to hook selected GUI programs;
|
|
read ANSICON_DEF environment variable to set the default GR;
|
|
transfer current GR to child, read it on exit.
|
|
|
|
v1.51, 15 January, 5, 22 & 24 February, 2012:
|
|
added log mask 16 to log all the imported modules of imported modules;
|
|
ignore the version within the core API DLL names;
|
|
fix 32-bit process trying to identify 64-bit process;
|
|
hook _lwrite & _hwrite.
|
|
|
|
v1.52, 10 April, 1 & 2 June, 2012:
|
|
use ansicon.exe to enable 32-bit to inject into 64-bit;
|
|
implement \e[39m & \e[49m (only setting color, nothing else);
|
|
added the character/line equivalents (keaj`) of the cursor movement
|
|
sequences (ABCDG), as well as vertical absolute (d) and erase characters
|
|
(X).
|
|
|
|
v1.53, 12 June, 2012:
|
|
fixed Update_GRM when running multiple processes (e.g. "cl /MP").
|
|
|
|
v1.60, 22 to 24 November, 2012:
|
|
alternative method to obtain LLW for 64->32 injection;
|
|
support for VC6 (remove section pragma, rename isdigit to is_digit).
|
|
|
|
v1.61, 14 February, 2013:
|
|
go back to using ANSI-LLW.exe for 64->32 injection.
|
|
|
|
v1.62, 17 & 18 July, 2013:
|
|
another method to obtain LLW for 64->32 injection.
|
|
|
|
v1.64, 2 August, 2013:
|
|
better method of determining a console handle (see IsConsoleHandle).
|
|
|
|
v1.65, 28 August, 2013:
|
|
fix \e[K (was using window, not buffer).
|
|
|
|
v1.66, 20 & 21 September, 2013:
|
|
fix 32-bit process trying to detect 64-bit process.
|
|
|
|
v1.70, 25 January to 26 February, 2014:
|
|
don't hook ourself from LoadLibrary or LoadLibraryEx;
|
|
update the LoadLibraryEx flags that should not cause hooking;
|
|
inject by manipulating the import directory table; for 64-bit AnyCPU use
|
|
ntdll's LdrLoadDll via CreateRemoteThread;
|
|
restore original attributes on detach (for LoadLibrary/FreeLibrary usage);
|
|
log: remove the quotes around the CreateProcess command line string and
|
|
distinguish NULL and "" args;
|
|
attributes (and saved position) are local to each console window;
|
|
exclude entire programs, by not using an extension in ANSICON_EXC;
|
|
hook modules injected via CreateRemoteThread+LoadLibrary;
|
|
hook all modules loaded due to LoadLibrary, not just the specified;
|
|
don't hook a module that's already hooked us;
|
|
better parsing of escape & CSI sequences;
|
|
ignore xterm 38 & 48 SGR values;
|
|
change G1 blank from space to U+00A0 - No-Break Space;
|
|
use window height, not buffer;
|
|
added more sequences;
|
|
don't add a newline immediately after a wrap;
|
|
restore cursor visibility on unload.
|
|
|
|
v1.71, 23 October, 2015:
|
|
add _CRT_NON_CONFORMING_WCSTOK define for VS2015.
|
|
|
|
v1.72, 14 to 24 December, 2015:
|
|
recognize the standard handle defines in WriteFile;
|
|
minor speed improvement by caching GetConsoleMode;
|
|
keep track of three handles (ostensibly stdout, stderr and a file);
|
|
test a DOS header exists before writing to e_oemid;
|
|
more flexible/robust handling of data directories;
|
|
files writing to the console will always succeed;
|
|
log: use API file functions and a custom printf;
|
|
add a blank line between processes;
|
|
set function name for MyWriteConsoleA;
|
|
scan imports from "kernel32" (without extension);
|
|
added dynamic environment variable CLICOLOR;
|
|
removed _hwrite (it's the same address as _lwrite);
|
|
join multibyte characters split across separate writes;
|
|
remove wcstok, avoiding potential interference with the host;
|
|
similarly, use a private heap instead of malloc.
|
|
|
|
v1.80, 26 October to 24 December, 2017:
|
|
fix unloading;
|
|
revert back to (re)storing buffer cursor position;
|
|
increase cache to five handles;
|
|
hook CreateFile & CreateConsoleScreenBuffer to enable readable handles;
|
|
fix cursor report with duplicated digits (e.g. "11" was just "1");
|
|
preserve escape that isn't part of a sequence;
|
|
fix escape followed by CRM in control mode;
|
|
use the system default sound for the bell;
|
|
add DECPS Play Sound;
|
|
use intermediate byte '+' to use buffer, not window;
|
|
ESC followed by a control character will display that character;
|
|
added palette sequences;
|
|
change the scan lines in the graphics set to their actual Unicode chars;
|
|
added IND, NEL & RI (using buffer, in keeping with LF);
|
|
added DA, DECCOLM, DECNCSM, DECSC & DECRC (with SGR & G0);
|
|
partially support SCS (just G0 as DEC special & ASCII);
|
|
an explicit zero parameter should still default to one;
|
|
restrict parameters to a maximum value of 32767;
|
|
added tab handling;
|
|
added the bright SGR colors, recognised the system indices;
|
|
added insert mode;
|
|
BS/CR/CUB/HPB after wrap will move back to the previous line(s);
|
|
added DECOM, DECSTBM, SD & SU;
|
|
only flush before accessing the console, adding a mode to flush immediately;
|
|
added DECSTR & RIS;
|
|
fix state problems with windowless processes.
|
|
*/
|
|
|
|
#include "ansicon.h"
|
|
#include "version.h"
|
|
#include <mmsystem.h>
|
|
|
|
#ifndef SND_SENTRY
|
|
#define SND_SENTRY 0x80000
|
|
#endif
|
|
|
|
#define is_digit(c) ('0' <= (c) && (c) <= '9')
|
|
|
|
// ========== Global variables and constants
|
|
|
|
HANDLE hConOut; // handle to CONOUT$
|
|
WORD orgattr; // original attributes
|
|
DWORD orgmode; // original mode
|
|
CONSOLE_CURSOR_INFO orgcci; // original cursor state
|
|
HANDLE hHeap; // local memory heap
|
|
HANDLE hBell;
|
|
|
|
#define CACHE 5
|
|
struct Cache
|
|
{
|
|
HANDLE h;
|
|
DWORD mode;
|
|
} cache[CACHE];
|
|
|
|
#define ESC '\x1B' // ESCape character
|
|
#define BEL '\x07' // BELl
|
|
#define HT '\x09' // Horizontal Tabulation
|
|
#define SO '\x0E' // Shift Out
|
|
#define SI '\x0F' // Shift In
|
|
|
|
#define MAX_ARG 16 // max number of args in an escape sequence
|
|
int state; // automata state
|
|
TCHAR prefix; // escape sequence prefix ( '[' or ']' );
|
|
TCHAR prefix2; // secondary prefix ( one of '<=>?' );
|
|
TCHAR suffix; // escape sequence final byte
|
|
TCHAR suffix2; // escape sequence intermediate byte
|
|
int ibytes; // count of intermediate bytes
|
|
int es_argc; // escape sequence args count
|
|
int es_argv[MAX_ARG]; // escape sequence args
|
|
TCHAR Pt_arg[MAX_PATH*2]; // text parameter for Operating System Command
|
|
int Pt_len;
|
|
BOOL shifted, G0_special, SaveG0;
|
|
BOOL awm = TRUE; // autowrap mode
|
|
BOOL im; // insert mode
|
|
int screen_top = -1; // initial window top when cleared
|
|
|
|
|
|
// DEC Special Graphics Character Set from
|
|
// http://vt100.net/docs/vt220-rm/table2-4.html
|
|
// Some of these may not look right, depending on the font and code page (in
|
|
// particular, the Control Pictures probably won't work at all).
|
|
const WCHAR G1[] =
|
|
{
|
|
L'\x00a0', // _ - No-Break Space
|
|
L'\x2666', // ` - Black Diamond Suit
|
|
L'\x2592', // a - Medium Shade
|
|
L'\x2409', // b - HT
|
|
L'\x240c', // c - FF
|
|
L'\x240d', // d - CR
|
|
L'\x240a', // e - LF
|
|
L'\x00b0', // f - Degree Sign
|
|
L'\x00b1', // g - Plus-Minus Sign
|
|
L'\x2424', // h - NL
|
|
L'\x240b', // i - VT
|
|
L'\x2518', // j - Box Drawings Light Up And Left
|
|
L'\x2510', // k - Box Drawings Light Down And Left
|
|
L'\x250c', // l - Box Drawings Light Down And Right
|
|
L'\x2514', // m - Box Drawings Light Up And Right
|
|
L'\x253c', // n - Box Drawings Light Vertical And Horizontal
|
|
L'\x23ba', // o - Horizontal Scan Line-1
|
|
L'\x23bb', // p - Horizontal Scan Line-3
|
|
L'\x2500', // q - Box Drawings Light Horizontal (SCAN 5)
|
|
L'\x23bc', // r - Horizontal Scan Line-7
|
|
L'\x23bd', // s - Horizontal Scan Line-9
|
|
L'\x251c', // t - Box Drawings Light Vertical And Right
|
|
L'\x2524', // u - Box Drawings Light Vertical And Left
|
|
L'\x2534', // v - Box Drawings Light Up And Horizontal
|
|
L'\x252c', // w - Box Drawings Light Down And Horizontal
|
|
L'\x2502', // x - Box Drawings Light Vertical
|
|
L'\x2264', // y - Less-Than Or Equal To
|
|
L'\x2265', // z - Greater-Than Or Equal To
|
|
L'\x03c0', // { - Greek Small Letter Pi
|
|
L'\x2260', // | - Not Equal To
|
|
L'\x00a3', // } - Pound Sign
|
|
L'\x00b7', // ~ - Middle Dot
|
|
};
|
|
|
|
#define FIRST_G1 '_'
|
|
#define LAST_G1 '~'
|
|
|
|
|
|
// color constants
|
|
|
|
#define FOREGROUND_BLACK 0
|
|
#define FOREGROUND_WHITE FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE
|
|
|
|
#define BACKGROUND_BLACK 0
|
|
#define BACKGROUND_WHITE BACKGROUND_RED|BACKGROUND_GREEN|BACKGROUND_BLUE
|
|
|
|
const BYTE foregroundcolor[16] =
|
|
{
|
|
FOREGROUND_BLACK, // black foreground
|
|
FOREGROUND_RED, // red foreground
|
|
FOREGROUND_GREEN, // green foreground
|
|
FOREGROUND_RED | FOREGROUND_GREEN, // yellow foreground
|
|
FOREGROUND_BLUE, // blue foreground
|
|
FOREGROUND_BLUE | FOREGROUND_RED, // magenta foreground
|
|
FOREGROUND_BLUE | FOREGROUND_GREEN, // cyan foreground
|
|
FOREGROUND_WHITE, // white foreground
|
|
FOREGROUND_INTENSITY | FOREGROUND_BLACK,
|
|
FOREGROUND_INTENSITY | FOREGROUND_RED,
|
|
FOREGROUND_INTENSITY | FOREGROUND_GREEN,
|
|
FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN,
|
|
FOREGROUND_INTENSITY | FOREGROUND_BLUE,
|
|
FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_RED,
|
|
FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_GREEN,
|
|
FOREGROUND_INTENSITY | FOREGROUND_WHITE
|
|
};
|
|
|
|
const BYTE backgroundcolor[16] =
|
|
{
|
|
BACKGROUND_BLACK, // black background
|
|
BACKGROUND_RED, // red background
|
|
BACKGROUND_GREEN, // green background
|
|
BACKGROUND_RED | BACKGROUND_GREEN, // yellow background
|
|
BACKGROUND_BLUE, // blue background
|
|
BACKGROUND_BLUE | BACKGROUND_RED, // magenta background
|
|
BACKGROUND_BLUE | BACKGROUND_GREEN, // cyan background
|
|
BACKGROUND_WHITE, // white background
|
|
BACKGROUND_INTENSITY | BACKGROUND_BLACK,
|
|
BACKGROUND_INTENSITY | BACKGROUND_RED,
|
|
BACKGROUND_INTENSITY | BACKGROUND_GREEN,
|
|
BACKGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN,
|
|
BACKGROUND_INTENSITY | BACKGROUND_BLUE,
|
|
BACKGROUND_INTENSITY | BACKGROUND_BLUE | BACKGROUND_RED,
|
|
BACKGROUND_INTENSITY | BACKGROUND_BLUE | BACKGROUND_GREEN,
|
|
BACKGROUND_INTENSITY | BACKGROUND_WHITE
|
|
};
|
|
|
|
const BYTE attr2ansi[16] = // map console attribute to ANSI number
|
|
{ // or vice versa
|
|
0, // black
|
|
4, // blue
|
|
2, // green
|
|
6, // cyan
|
|
1, // red
|
|
5, // magenta
|
|
3, // yellow
|
|
7, // white
|
|
8, // bright black
|
|
12, // bright blue
|
|
10, // bright green
|
|
14, // bright cyan
|
|
9, // bright red
|
|
13, // bright magenta
|
|
11, // bright yellow
|
|
15, // bright white
|
|
};
|
|
|
|
|
|
typedef struct _CONSOLE_SCREEN_BUFFER_INFOX {
|
|
ULONG cbSize;
|
|
COORD dwSize;
|
|
COORD dwCursorPosition;
|
|
WORD wAttributes;
|
|
SMALL_RECT srWindow;
|
|
COORD dwMaximumWindowSize;
|
|
WORD wPopupAttributes;
|
|
BOOL bFullscreenSupported;
|
|
COLORREF ColorTable[16];
|
|
} CONSOLE_SCREEN_BUFFER_INFOX, *PCONSOLE_SCREEN_BUFFER_INFOX;
|
|
|
|
typedef BOOL (WINAPI *PHCSBIX)(
|
|
HANDLE hConsoleOutput,
|
|
PCONSOLE_SCREEN_BUFFER_INFOX lpConsoleScreenBufferInfoEx
|
|
);
|
|
|
|
PHCSBIX GetConsoleScreenBufferInfoX, SetConsoleScreenBufferInfoX;
|
|
|
|
|
|
typedef struct _CONSOLE_FONT_INFOX {
|
|
ULONG cbSize;
|
|
DWORD nFont;
|
|
COORD dwFontSize;
|
|
UINT FontFamily;
|
|
UINT FontWeight;
|
|
WCHAR FaceName[LF_FACESIZE];
|
|
} CONSOLE_FONT_INFOX, *PCONSOLE_FONT_INFOX;
|
|
|
|
typedef BOOL (WINAPI *PHBCFIX)(
|
|
HANDLE hConsoleOutput,
|
|
BOOL bMaximumWindow,
|
|
PCONSOLE_FONT_INFOX lpConsoleCurrentFontEx
|
|
);
|
|
|
|
PHBCFIX SetCurrentConsoleFontX;
|
|
|
|
|
|
// Reduce verbosity.
|
|
#define CURPOS dwCursorPosition
|
|
#define ATTR Info.wAttributes
|
|
#define WIDTH Info.dwSize.X
|
|
#define HEIGHT Info.dwSize.Y
|
|
#define CUR Info.CURPOS
|
|
#define WIN Info.srWindow
|
|
#define TOP WIN.Top
|
|
#define BOTTOM WIN.Bottom
|
|
#define LAST (HEIGHT - 1)
|
|
#define LEFT 0
|
|
#define RIGHT (WIDTH - 1)
|
|
|
|
|
|
#define MAX_TABS 2048
|
|
|
|
typedef struct
|
|
{
|
|
BYTE foreground; // ANSI base color (0 to 7; add 30)
|
|
BYTE background; // ANSI base color (0 to 7; add 40)
|
|
BYTE bold; // console FOREGROUND_INTENSITY bit
|
|
BYTE underline; // console BACKGROUND_INTENSITY bit
|
|
BYTE rvideo; // swap foreground/bold & background/underline
|
|
BYTE concealed; // set foreground/bold to background/underline
|
|
BYTE reverse; // swap console foreground & background attributes
|
|
} SGR;
|
|
|
|
typedef struct
|
|
{
|
|
SGR sgr, SaveSgr;
|
|
WORD SaveAttr;
|
|
BYTE fm; // flush mode
|
|
BYTE crm; // showing control characters?
|
|
BYTE om; // origin mode
|
|
BYTE tb_margins; // top/bottom margins set?
|
|
SHORT top_margin;
|
|
SHORT bot_margin;
|
|
COORD SavePos; // saved cursor position
|
|
COLORREF palette[16];
|
|
SHORT buf_width; // buffer width prior to setting 132 columns
|
|
SHORT win_width; // window width prior to setting 132 columns
|
|
BYTE noclear; // don't clear the screen on column mode change
|
|
BYTE tabs; // handle tabs directly
|
|
BYTE tab_stop[MAX_TABS];
|
|
} STATE, *PSTATE;
|
|
|
|
STATE default_state; // for when there's no window or file mapping
|
|
PSTATE pState = &default_state;
|
|
BOOL valid_state;
|
|
HANDLE hMap;
|
|
|
|
void set_ansicon( PCONSOLE_SCREEN_BUFFER_INFO );
|
|
|
|
|
|
void get_state( void )
|
|
{
|
|
TCHAR buf[64];
|
|
HWND hwnd;
|
|
BOOL init;
|
|
HANDLE hConOut;
|
|
CONSOLE_SCREEN_BUFFER_INFO Info;
|
|
CONSOLE_SCREEN_BUFFER_INFOX csbix;
|
|
|
|
if (valid_state)
|
|
return;
|
|
|
|
hwnd = GetConsoleWindow();
|
|
if (hwnd == NULL)
|
|
return;
|
|
|
|
valid_state = TRUE;
|
|
|
|
wsprintf( buf, L"ANSICON_State_%X", PtrToUint( hwnd ) );
|
|
hMap = CreateFileMapping( INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
|
|
0, sizeof(STATE), buf );
|
|
init = (GetLastError() != ERROR_ALREADY_EXISTS);
|
|
pState = MapViewOfFile( hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0 );
|
|
if (pState == NULL)
|
|
{
|
|
DEBUGSTR( 1, "File mapping failed (%u) - using default state",
|
|
GetLastError() );
|
|
pState = &default_state;
|
|
CloseHandle( hMap );
|
|
hMap = NULL;
|
|
}
|
|
|
|
if (init)
|
|
{
|
|
hConOut = CreateFile( L"CONOUT$", GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL, OPEN_EXISTING, 0, NULL );
|
|
csbix.cbSize = sizeof(csbix);
|
|
if (GetConsoleScreenBufferInfoX &&
|
|
GetConsoleScreenBufferInfoX( hConOut, &csbix ))
|
|
{
|
|
Info.dwSize = csbix.dwSize;
|
|
ATTR = csbix.wAttributes;
|
|
WIN = csbix.srWindow;
|
|
memcpy( pState->palette, csbix.ColorTable, sizeof(csbix.ColorTable) );
|
|
}
|
|
else if (!GetConsoleScreenBufferInfo( hConOut, &Info ))
|
|
{
|
|
DEBUGSTR( 1, "Failed to get screen buffer info (%u) - assuming defaults",
|
|
GetLastError() );
|
|
ATTR = 7;
|
|
WIDTH = 80;
|
|
HEIGHT = 300;
|
|
WIN.Left = 0;
|
|
WIN.Right = 79;
|
|
TOP = 0;
|
|
BOTTOM = 24;
|
|
}
|
|
if (GetEnvironmentVariable( L"ANSICON_REVERSE", NULL, 0 ))
|
|
{
|
|
SetEnvironmentVariable( L"ANSICON_REVERSE", NULL );
|
|
pState->sgr.reverse = TRUE;
|
|
pState->sgr.foreground = attr2ansi[(ATTR >> 4) & 7];
|
|
pState->sgr.background = attr2ansi[ATTR & 7];
|
|
pState->sgr.bold = (ATTR & BACKGROUND_INTENSITY) >> 4;
|
|
pState->sgr.underline = (ATTR & FOREGROUND_INTENSITY) << 4;
|
|
}
|
|
else
|
|
{
|
|
pState->sgr.foreground = attr2ansi[ATTR & 7];
|
|
pState->sgr.background = attr2ansi[(ATTR >> 4) & 7];
|
|
pState->sgr.bold = ATTR & FOREGROUND_INTENSITY;
|
|
pState->sgr.underline = ATTR & BACKGROUND_INTENSITY;
|
|
}
|
|
if (!GetEnvironmentVariable( L"ANSICON_DEF", NULL, 0 ))
|
|
{
|
|
TCHAR def[4];
|
|
LPTSTR a = def;
|
|
if (pState->sgr.reverse)
|
|
{
|
|
*a++ = '-';
|
|
ATTR = ((ATTR >> 4) & 15) | ((ATTR & 15) << 4);
|
|
}
|
|
wsprintf( a, L"%X", ATTR & 255 );
|
|
SetEnvironmentVariable( L"ANSICON_DEF", def );
|
|
}
|
|
set_ansicon( &Info );
|
|
CloseHandle( hConOut );
|
|
}
|
|
}
|
|
|
|
|
|
// Search an environment variable for a string.
|
|
BOOL search_env( LPCTSTR var, LPCTSTR val )
|
|
{
|
|
static LPTSTR env;
|
|
static DWORD env_len;
|
|
DWORD len;
|
|
BOOL not;
|
|
LPTSTR end;
|
|
|
|
len = GetEnvironmentVariable( var, env, env_len );
|
|
if (len == 0)
|
|
return FALSE;
|
|
|
|
if (len > env_len)
|
|
{
|
|
LPTSTR tmp = (env == NULL) ? HeapAlloc( hHeap, 0, TSIZE(len) )
|
|
: HeapReAlloc( hHeap, 0, env, TSIZE(len) );
|
|
if (tmp == NULL)
|
|
return FALSE;
|
|
env = tmp;
|
|
env_len = (DWORD)HeapSize( hHeap, 0, env );
|
|
GetEnvironmentVariable( var, env, env_len );
|
|
}
|
|
|
|
not = (*env == '!');
|
|
if (not && env[1] == '\0')
|
|
return TRUE;
|
|
|
|
end = env + not;
|
|
while (*end != '\0')
|
|
{
|
|
var = end;
|
|
do
|
|
{
|
|
if (*end++ == ';')
|
|
{
|
|
end[-1] = '\0';
|
|
break;
|
|
}
|
|
} while (*end != '\0');
|
|
if (_wcsicmp( val, var ) == 0)
|
|
return !not;
|
|
}
|
|
|
|
return not;
|
|
}
|
|
|
|
|
|
// ========== Print Buffer functions
|
|
|
|
#define BUFFER_SIZE 2048
|
|
|
|
int nCharInBuffer;
|
|
WCHAR ChBuffer[BUFFER_SIZE];
|
|
WCHAR ChPrev;
|
|
int nWrapped;
|
|
CRITICAL_SECTION CritSect;
|
|
HANDLE hFlushTimer;
|
|
|
|
void MoveDown( BOOL home );
|
|
|
|
|
|
// Set the cursor position, resetting the wrap flag.
|
|
void set_pos( int x, int y )
|
|
{
|
|
COORD pos = { x, y };
|
|
SetConsoleCursorPosition( hConOut, pos );
|
|
nWrapped = 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// FlushBuffer()
|
|
// Writes the buffer to the console and empties it.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FlushBuffer( void )
|
|
{
|
|
DWORD nWritten;
|
|
|
|
if (nCharInBuffer <= 0) return;
|
|
|
|
EnterCriticalSection( &CritSect );
|
|
|
|
if (!awm && !im)
|
|
{
|
|
if (pState->crm)
|
|
{
|
|
SetConsoleMode( hConOut, cache[0].mode & ~ENABLE_PROCESSED_OUTPUT );
|
|
WriteConsole( hConOut, ChBuffer, nCharInBuffer, &nWritten, NULL );
|
|
SetConsoleMode( hConOut, cache[0].mode );
|
|
}
|
|
else
|
|
WriteConsole( hConOut, ChBuffer, nCharInBuffer, &nWritten, NULL );
|
|
}
|
|
else
|
|
{
|
|
HANDLE hConWrap;
|
|
CONSOLE_CURSOR_INFO cci;
|
|
CONSOLE_SCREEN_BUFFER_INFO Info, wi;
|
|
|
|
if (nCharInBuffer < 4 && !im && !pState->tb_margins)
|
|
{
|
|
LPWSTR b = ChBuffer;
|
|
if (pState->crm)
|
|
SetConsoleMode( hConOut, cache[0].mode & ~ENABLE_PROCESSED_OUTPUT );
|
|
do
|
|
{
|
|
WriteConsole( hConOut, b, 1, &nWritten, NULL );
|
|
if (pState->crm || (*b != '\r' && *b != '\b' && *b != '\a'))
|
|
{
|
|
GetConsoleScreenBufferInfo( hConOut, &Info );
|
|
if (CUR.X == 0)
|
|
++nWrapped;
|
|
}
|
|
} while (++b, --nCharInBuffer);
|
|
if (pState->crm)
|
|
SetConsoleMode( hConOut, cache[0].mode );
|
|
}
|
|
else
|
|
{
|
|
// To detect wrapping of multiple characters, create a new buffer, write
|
|
// to the top of it and see if the cursor changes line. This doesn't
|
|
// always work on the normal buffer, since if you're already on the last
|
|
// line, wrapping scrolls everything up and still leaves you on the last.
|
|
hConWrap = CreateConsoleScreenBuffer( GENERIC_READ|GENERIC_WRITE, 0, NULL,
|
|
CONSOLE_TEXTMODE_BUFFER, NULL );
|
|
// Even though the buffer isn't visible, the cursor still shows up.
|
|
cci.dwSize = 1;
|
|
cci.bVisible = FALSE;
|
|
SetConsoleCursorInfo( hConWrap, &cci );
|
|
// Ensure the buffer is the same width (it gets created using the window
|
|
// width) and contains sufficient lines.
|
|
GetConsoleScreenBufferInfo( hConOut, &Info );
|
|
if (WIN.Right - WIN.Left + 1 != WIDTH ||
|
|
BOTTOM - TOP < 2 * nCharInBuffer % WIDTH)
|
|
{
|
|
HEIGHT = 2 * nCharInBuffer % WIDTH + 1;
|
|
SetConsoleScreenBufferSize( hConWrap, Info.dwSize );
|
|
}
|
|
// Put the cursor on the top line, in the same column.
|
|
wi.CURPOS.X = CUR.X;
|
|
wi.CURPOS.Y = 0;
|
|
SetConsoleCursorPosition( hConWrap, wi.CURPOS );
|
|
if (pState->crm)
|
|
SetConsoleMode( hConWrap, (awm) ? ENABLE_WRAP_AT_EOL_OUTPUT : 0 );
|
|
else if (!awm)
|
|
SetConsoleMode( hConWrap, ENABLE_PROCESSED_OUTPUT );
|
|
WriteConsole( hConWrap, ChBuffer, nCharInBuffer, &nWritten, NULL );
|
|
GetConsoleScreenBufferInfo( hConWrap, &wi );
|
|
if (pState->tb_margins && CUR.Y + wi.CURPOS.Y > TOP + pState->bot_margin)
|
|
{
|
|
if (CUR.Y > TOP + pState->bot_margin)
|
|
{
|
|
// If we're at the bottom of the window, outside the margins, then
|
|
// just keep overwriting the last line.
|
|
if (CUR.Y + wi.CURPOS.Y > BOTTOM)
|
|
{
|
|
PCHAR_INFO row = HeapAlloc( hHeap, 0, WIDTH * sizeof(CHAR_INFO) );
|
|
if (row != NULL)
|
|
{
|
|
COORD s, c;
|
|
SMALL_RECT r;
|
|
s.X = WIDTH;
|
|
s.Y = 1;
|
|
c.X = c.Y = 0;
|
|
for (r.Top = 0; r.Top <= wi.CURPOS.Y; ++r.Top)
|
|
{
|
|
if (r.Top == 0)
|
|
{
|
|
r.Left = CUR.X;
|
|
r.Right = RIGHT;
|
|
}
|
|
else if (r.Top == wi.CURPOS.Y)
|
|
{
|
|
r.Left = LEFT;
|
|
r.Right = wi.CURPOS.X - 1;
|
|
}
|
|
else
|
|
{
|
|
r.Left = LEFT;
|
|
r.Right = RIGHT;
|
|
}
|
|
r.Bottom = r.Top;
|
|
ReadConsoleOutput( hConWrap, row, s, c, &r );
|
|
r.Top = r.Bottom = CUR.Y;
|
|
WriteConsoleOutput( hConOut, row, s, c, &r );
|
|
if (CUR.Y != BOTTOM)
|
|
++CUR.Y;
|
|
}
|
|
HeapFree( hHeap, 0, row );
|
|
CloseHandle( hConWrap );
|
|
nWrapped = 0;
|
|
goto done;
|
|
}
|
|
}
|
|
}
|
|
else if (wi.CURPOS.Y > pState->bot_margin - pState->top_margin)
|
|
{
|
|
// The line is bigger than the scroll region, copy that portion.
|
|
PCHAR_INFO row = HeapAlloc( hHeap, 0,
|
|
(pState->bot_margin - pState->top_margin + 1)
|
|
* WIDTH * sizeof(CHAR_INFO) );
|
|
if (row != NULL)
|
|
{
|
|
COORD s, c;
|
|
SMALL_RECT r;
|
|
s.X = WIDTH;
|
|
s.Y = pState->bot_margin - pState->top_margin + 1;
|
|
c.X = c.Y = 0;
|
|
r.Left = LEFT;
|
|
r.Right = RIGHT;
|
|
r.Bottom = wi.CURPOS.Y;
|
|
r.Top = r.Bottom - (pState->bot_margin - pState->top_margin);
|
|
ReadConsoleOutput( hConWrap, row, s, c, &r );
|
|
r.Top = TOP + pState->top_margin;
|
|
r.Bottom = TOP + pState->bot_margin;
|
|
WriteConsoleOutput( hConOut, row, s, c, &r );
|
|
HeapFree( hHeap, 0, row );
|
|
CloseHandle( hConWrap );
|
|
nWrapped = pState->bot_margin - pState->top_margin;
|
|
goto done;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Scroll the region, then write as normal.
|
|
SMALL_RECT sr;
|
|
COORD c;
|
|
CHAR_INFO ci;
|
|
|
|
ci.Char.UnicodeChar = ' ';
|
|
ci.Attributes = ATTR;
|
|
c.X =
|
|
sr.Left = LEFT;
|
|
sr.Right = RIGHT;
|
|
sr.Top = TOP + pState->top_margin;
|
|
sr.Bottom = TOP + pState->bot_margin;
|
|
c.Y = sr.Top - wi.CURPOS.Y;
|
|
ScrollConsoleScreenBuffer( hConOut, &sr, &sr, c, &ci );
|
|
CUR.Y -= wi.CURPOS.Y;
|
|
SetConsoleCursorPosition( hConOut, CUR );
|
|
}
|
|
}
|
|
nWrapped += wi.CURPOS.Y;
|
|
CloseHandle( hConWrap );
|
|
if (im && !nWrapped)
|
|
{
|
|
SMALL_RECT sr, cr;
|
|
CHAR_INFO ci; // unused, but necessary
|
|
|
|
cr.Top = cr.Bottom = sr.Top = sr.Bottom = CUR.Y;
|
|
cr.Right = sr.Right = RIGHT;
|
|
sr.Left = CUR.X;
|
|
cr.Left = CUR.X = wi.CURPOS.X;
|
|
ScrollConsoleScreenBuffer( hConOut, &sr, &cr, CUR, &ci );
|
|
}
|
|
if (pState->crm)
|
|
{
|
|
SetConsoleMode( hConOut, cache[0].mode & ~ENABLE_PROCESSED_OUTPUT );
|
|
WriteConsole( hConOut, ChBuffer, nCharInBuffer, &nWritten, NULL );
|
|
SetConsoleMode( hConOut, cache[0].mode );
|
|
}
|
|
else
|
|
WriteConsole( hConOut, ChBuffer, nCharInBuffer, &nWritten, NULL );
|
|
}
|
|
}
|
|
done:
|
|
nCharInBuffer = 0;
|
|
|
|
LeaveCriticalSection( &CritSect );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// PushBuffer( WCHAR c )
|
|
// Adds a character in the buffer.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PushBuffer( WCHAR c )
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO Info;
|
|
|
|
ChPrev = c;
|
|
|
|
if (c == '\n')
|
|
{
|
|
if (pState->crm)
|
|
ChBuffer[nCharInBuffer++] = c;
|
|
FlushBuffer();
|
|
// Avoid writing the newline if wrap has already occurred.
|
|
GetConsoleScreenBufferInfo( hConOut, &Info );
|
|
if (pState->crm)
|
|
{
|
|
// If we're displaying controls, then the only way we can be on the left
|
|
// margin is if wrap occurred.
|
|
if (CUR.X != 0)
|
|
MoveDown( TRUE );
|
|
}
|
|
else
|
|
{
|
|
BOOL nl = TRUE;
|
|
if (nWrapped)
|
|
{
|
|
// It's wrapped, but was anything more written? Look at the current
|
|
// row, checking that each character is space in current attributes.
|
|
// If it's all blank we can drop the newline. If the cursor isn't
|
|
// already at the margin, then it was spaces or tabs that caused the
|
|
// wrap, which can be ignored and overwritten.
|
|
CHAR_INFO blank;
|
|
PCHAR_INFO row = HeapAlloc( hHeap, 0, WIDTH * sizeof(CHAR_INFO) );
|
|
if (row != NULL)
|
|
{
|
|
COORD s, c;
|
|
SMALL_RECT r;
|
|
s.X = WIDTH;
|
|
s.Y = 1;
|
|
c.X = c.Y = 0;
|
|
r.Left = LEFT;
|
|
r.Right = RIGHT;
|
|
r.Top = r.Bottom = CUR.Y;
|
|
ReadConsoleOutput( hConOut, row, s, c, &r );
|
|
blank.Char.UnicodeChar = ' ';
|
|
blank.Attributes = ATTR;
|
|
while (*(PDWORD)&row[c.X] == *(PDWORD)&blank)
|
|
{
|
|
if (++c.X == s.X)
|
|
{
|
|
if (CUR.X != 0)
|
|
{
|
|
CUR.X = 0;
|
|
SetConsoleCursorPosition( hConOut, CUR );
|
|
}
|
|
nl = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
HeapFree( hHeap, 0, row );
|
|
}
|
|
nWrapped = 0;
|
|
}
|
|
if (nl)
|
|
MoveDown( TRUE );
|
|
}
|
|
}
|
|
else if (c == '\r')
|
|
{
|
|
FlushBuffer();
|
|
if (nWrapped)
|
|
{
|
|
GetConsoleScreenBufferInfo( hConOut, &Info );
|
|
CUR.Y -= nWrapped;
|
|
if (CUR.Y < 0) CUR.Y = 0;
|
|
if (pState->tb_margins && CUR.Y < TOP) CUR.Y = TOP;
|
|
set_pos( LEFT, CUR.Y );
|
|
}
|
|
else
|
|
ChBuffer[nCharInBuffer++] = c;
|
|
}
|
|
else if (c == '\b')
|
|
{
|
|
BOOL bs = FALSE;
|
|
FlushBuffer();
|
|
if (nWrapped)
|
|
{
|
|
GetConsoleScreenBufferInfo( hConOut, &Info );
|
|
if (CUR.X == LEFT)
|
|
{
|
|
CUR.X = RIGHT;
|
|
CUR.Y--;
|
|
SetConsoleCursorPosition( hConOut, CUR );
|
|
--nWrapped;
|
|
bs = TRUE;
|
|
}
|
|
}
|
|
if (!bs)
|
|
ChBuffer[nCharInBuffer++] = c;
|
|
}
|
|
else
|
|
{
|
|
if (shifted && c >= FIRST_G1 && c <= LAST_G1)
|
|
c = G1[c-FIRST_G1];
|
|
ChBuffer[nCharInBuffer] = c;
|
|
if (++nCharInBuffer == BUFFER_SIZE)
|
|
FlushBuffer();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SendSequence( LPTSTR seq )
|
|
// Send the string to the input buffer.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SendSequence( LPTSTR seq )
|
|
{
|
|
DWORD out;
|
|
PINPUT_RECORD in;
|
|
DWORD len;
|
|
HANDLE hStdIn = GetStdHandle( STD_INPUT_HANDLE );
|
|
|
|
in = HeapAlloc( hHeap, HEAP_ZERO_MEMORY, 2 * wcslen( seq ) * sizeof(*in) );
|
|
if (in == NULL)
|
|
return;
|
|
for (len = 0; *seq; len += 2, ++seq)
|
|
{
|
|
in[len+0].EventType =
|
|
in[len+1].EventType = KEY_EVENT;
|
|
in[len+0].Event.KeyEvent.wRepeatCount =
|
|
in[len+1].Event.KeyEvent.wRepeatCount = 1;
|
|
in[len+0].Event.KeyEvent.uChar.UnicodeChar =
|
|
in[len+1].Event.KeyEvent.uChar.UnicodeChar = *seq;
|
|
in[len+0].Event.KeyEvent.bKeyDown = TRUE;
|
|
}
|
|
WriteConsoleInput( hStdIn, in, len, &out );
|
|
HeapFree( hHeap, 0, in );
|
|
}
|
|
|
|
void send_palette_sequence( COLORREF c )
|
|
{
|
|
BYTE r, g, b;
|
|
TCHAR buf[16];
|
|
|
|
r = GetRValue( c );
|
|
g = GetGValue( c );
|
|
b = GetBValue( c );
|
|
if ((c & 0x0F0F0F) == ((c & 0xF0F0F0) >> 4))
|
|
wsprintf( buf, L"#%X%X%X", r & 0xF, g & 0xF, b & 0xF );
|
|
else
|
|
wsprintf( buf, L"#%02X%02X%02X", r, g, b );
|
|
SendSequence( buf );
|
|
}
|
|
|
|
|
|
// Clear existing tabs and set tab stops at every size columns.
|
|
void init_tabs( int size )
|
|
{
|
|
int i;
|
|
|
|
memset( pState->tab_stop, FALSE, MAX_TABS );
|
|
for (i = 0; i < MAX_TABS; i += size)
|
|
pState->tab_stop[i] = TRUE;
|
|
pState->tabs = TRUE;
|
|
}
|
|
|
|
|
|
// ========== Reset
|
|
|
|
void InterpretEscSeq( void );
|
|
|
|
void Reset( BOOL hard )
|
|
{
|
|
CONSOLE_CURSOR_INFO CursInfo;
|
|
CONSOLE_SCREEN_BUFFER_INFOX csbix;
|
|
|
|
GetConsoleCursorInfo( hConOut, &CursInfo );
|
|
CursInfo.bVisible = TRUE;
|
|
SetConsoleCursorInfo( hConOut, &CursInfo );
|
|
im =
|
|
pState->om =
|
|
pState->crm =
|
|
pState->tb_margins = FALSE;
|
|
awm = TRUE;
|
|
SetConsoleMode( hConOut, cache[0].mode | ENABLE_WRAP_AT_EOL_OUTPUT );
|
|
shifted = G0_special = SaveG0 = FALSE;
|
|
pState->SavePos.X = pState->SavePos.Y = 0;
|
|
pState->SaveAttr = 0;
|
|
es_argv[0] = es_argc = 0;
|
|
prefix = '[';
|
|
prefix2 = suffix2 = 0;
|
|
suffix = 'm';
|
|
InterpretEscSeq();
|
|
|
|
if (hard)
|
|
{
|
|
pState->tabs =
|
|
pState->noclear = FALSE;
|
|
prefix2 = '?';
|
|
es_argv[0] = 3; es_argc = 1;
|
|
suffix2 = '+';
|
|
suffix = 'l';
|
|
InterpretEscSeq();
|
|
screen_top = -1;
|
|
csbix.cbSize = sizeof(csbix);
|
|
if (GetConsoleScreenBufferInfoX &&
|
|
GetConsoleScreenBufferInfoX( hConOut, &csbix ))
|
|
{
|
|
memcpy( csbix.ColorTable, pState->palette, sizeof(csbix.ColorTable) );
|
|
++csbix.srWindow.Right;
|
|
++csbix.srWindow.Bottom;
|
|
SetConsoleScreenBufferInfoX( hConOut, &csbix );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ========== Print functions
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// InterpretEscSeq()
|
|
// Interprets the last escape sequence scanned by ParseAndPrintString
|
|
// prefix escape sequence prefix
|
|
// es_argc escape sequence args count
|
|
// es_argv[] escape sequence args array
|
|
// suffix escape sequence suffix
|
|
//
|
|
// for instance, with \e[33;45;1m we have
|
|
// prefix = '[',
|
|
// es_argc = 3, es_argv[0] = 33, es_argv[1] = 45, es_argv[2] = 1
|
|
// suffix = 'm'
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void InterpretEscSeq( void )
|
|
{
|
|
int i;
|
|
int p1, p2;
|
|
WORD attribut;
|
|
CONSOLE_SCREEN_BUFFER_INFO Info;
|
|
CONSOLE_CURSOR_INFO CursInfo;
|
|
DWORD len, NumberOfCharsWritten;
|
|
COORD Pos;
|
|
SMALL_RECT Rect;
|
|
CHAR_INFO CharInfo;
|
|
DWORD mode;
|
|
SHORT top, bottom;
|
|
|
|
#define FillBlank( len, Pos ) \
|
|
FillConsoleOutputCharacter( hConOut, ' ', len, Pos, &NumberOfCharsWritten );\
|
|
FillConsoleOutputAttribute( hConOut, ATTR, len, Pos, &NumberOfCharsWritten )
|
|
|
|
if (prefix == '[')
|
|
{
|
|
if (prefix2 == '?' && (suffix2 == 0 || suffix2 == '+'))
|
|
{
|
|
if (suffix == 'h' || suffix == 'l')
|
|
{
|
|
for (i = 0; i < es_argc; i++)
|
|
switch (es_argv[i])
|
|
{
|
|
case 25: // DECTCEM
|
|
GetConsoleCursorInfo( hConOut, &CursInfo );
|
|
CursInfo.bVisible = (suffix == 'h');
|
|
SetConsoleCursorInfo( hConOut, &CursInfo );
|
|
break;
|
|
|
|
case 7: // DECAWM
|
|
awm = (suffix == 'h');
|
|
mode = cache[0].mode;
|
|
if (awm)
|
|
mode |= ENABLE_WRAP_AT_EOL_OUTPUT;
|
|
else
|
|
mode &= ~ENABLE_WRAP_AT_EOL_OUTPUT;
|
|
SetConsoleMode( hConOut, mode );
|
|
break;
|
|
|
|
case 6: // DECOM
|
|
pState->om = (suffix == 'h');
|
|
break;
|
|
|
|
case 95: // DECNCSM
|
|
pState->noclear = (suffix == 'h');
|
|
break;
|
|
|
|
case 3: // DECCOLM
|
|
{
|
|
COORD buf;
|
|
SMALL_RECT win;
|
|
|
|
pState->tb_margins = FALSE;
|
|
|
|
buf.X = (suffix == 'l') ? pState->buf_width : 132;
|
|
if (buf.X != 0)
|
|
{
|
|
GetConsoleScreenBufferInfo( hConOut, &Info );
|
|
buf.Y = HEIGHT;
|
|
win.Left = LEFT;
|
|
win.Top = TOP;
|
|
win.Bottom = BOTTOM;
|
|
if (suffix == 'h')
|
|
{
|
|
pState->buf_width = WIDTH;
|
|
pState->win_width = WIN.Right - WIN.Left;
|
|
win.Right = 131;
|
|
}
|
|
else
|
|
{
|
|
win.Right = pState->win_width;
|
|
pState->buf_width = 0;
|
|
}
|
|
// The buffer cannot be smaller than the window; the window
|
|
// cannot be bigger than the buffer.
|
|
if (WIN.Right - WIN.Left > win.Right)
|
|
{
|
|
SetConsoleWindowInfo( hConOut, TRUE, &win );
|
|
SetConsoleScreenBufferSize( hConOut, buf );
|
|
}
|
|
else
|
|
{
|
|
SetConsoleScreenBufferSize( hConOut, buf );
|
|
SetConsoleWindowInfo( hConOut, TRUE, &win );
|
|
}
|
|
}
|
|
// Even if the screen is not cleared, scroll in a new window the
|
|
// first time this is used.
|
|
if (pState->noclear &&
|
|
(suffix2 == '+' || (TOP == screen_top && CUR.Y != LAST)))
|
|
{
|
|
set_pos( LEFT, (suffix2 == '+') ? 0 : TOP );
|
|
break;
|
|
}
|
|
prefix2 = 0;
|
|
es_argv[0] = 2;
|
|
suffix = 'J';
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (suffix == 'W') // DECST8C
|
|
{
|
|
if (es_argv[0] != 5 || es_argc > 2) return;
|
|
if (es_argc == 1) es_argv[1] = 8;
|
|
init_tabs( es_argv[1] );
|
|
return;
|
|
}
|
|
}
|
|
// Ignore any other private sequences.
|
|
if (prefix2 != 0)
|
|
return;
|
|
|
|
// Even an explicit parameter of 0 should be defaulted to 1.
|
|
p1 = (es_argv[0] == 0) ? 1 : es_argv[0];
|
|
p2 = (es_argv[1] == 0) ? 1 : es_argv[1];
|
|
|
|
GetConsoleScreenBufferInfo( hConOut, &Info );
|
|
if (suffix2 == '+')
|
|
{
|
|
top = 0;
|
|
bottom = LAST;
|
|
}
|
|
else
|
|
{
|
|
top = TOP;
|
|
bottom = BOTTOM;
|
|
}
|
|
if (suffix2 == 0 || suffix2 == '+') switch (suffix)
|
|
{
|
|
case 'm': // SGR
|
|
if (es_argc == 0) es_argc++; // ESC[m == ESC[0m
|
|
for (i = 0; i < es_argc; i++)
|
|
{
|
|
if (30 <= es_argv[i] && es_argv[i] <= 37)
|
|
{
|
|
pState->sgr.foreground = es_argv[i] - 30;
|
|
}
|
|
else if (40 <= es_argv[i] && es_argv[i] <= 47)
|
|
{
|
|
pState->sgr.background = es_argv[i] - 40;
|
|
}
|
|
else if (90 <= es_argv[i] && es_argv[i] <= 97)
|
|
{
|
|
pState->sgr.foreground = es_argv[i] - 90 + 8;
|
|
}
|
|
else if (100 <= es_argv[i] && es_argv[i] <= 107)
|
|
{
|
|
pState->sgr.background = es_argv[i] - 100 + 8;
|
|
}
|
|
else if (es_argv[i] == 38 || es_argv[i] == 48)
|
|
{
|
|
// This is technically incorrect, but it's what xterm does, so
|
|
// that's what we do. According to T.416 (ISO 8613-6), there is
|
|
// only one parameter, which is divided into elements. So where
|
|
// xterm does "38;2;R;G;B" it should really be "38:2:I:R:G:B" (I is
|
|
// a color space identifier).
|
|
if (i+1 < es_argc)
|
|
{
|
|
if (es_argv[i+1] == 2) // rgb
|
|
i += 4;
|
|
else if (es_argv[i+1] == 5) // index
|
|
{
|
|
if (i+2 < es_argc && es_argv[i+2] < 16)
|
|
{
|
|
if (es_argv[i] == 38)
|
|
{
|
|
pState->sgr.foreground = es_argv[i+2];
|
|
pState->sgr.bold = es_argv[i+2] & FOREGROUND_INTENSITY;
|
|
}
|
|
else
|
|
{
|
|
pState->sgr.background = es_argv[i+2];
|
|
pState->sgr.underline = es_argv[i+2] & BACKGROUND_INTENSITY;
|
|
}
|
|
}
|
|
i += 2;
|
|
}
|
|
}
|
|
}
|
|
else switch (es_argv[i])
|
|
{
|
|
case 0:
|
|
case 39:
|
|
case 49:
|
|
{
|
|
TCHAR def[4];
|
|
int a;
|
|
*def = '7'; def[1] = '\0';
|
|
GetEnvironmentVariable( L"ANSICON_DEF", def, lenof(def) );
|
|
a = wcstol( def, NULL, 16 );
|
|
pState->sgr.reverse = FALSE;
|
|
if (a < 0)
|
|
{
|
|
pState->sgr.reverse = TRUE;
|
|
a = -a;
|
|
}
|
|
if (es_argv[i] != 49)
|
|
pState->sgr.foreground = attr2ansi[a & 7];
|
|
if (es_argv[i] != 39)
|
|
pState->sgr.background = attr2ansi[(a >> 4) & 7];
|
|
if (es_argv[i] == 0)
|
|
{
|
|
if (es_argc == 1)
|
|
{
|
|
pState->sgr.bold = a & FOREGROUND_INTENSITY;
|
|
pState->sgr.underline = a & BACKGROUND_INTENSITY;
|
|
}
|
|
else
|
|
{
|
|
pState->sgr.bold = 0;
|
|
pState->sgr.underline = 0;
|
|
}
|
|
pState->sgr.rvideo = 0;
|
|
pState->sgr.concealed = 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 1: pState->sgr.bold = FOREGROUND_INTENSITY; break;
|
|
case 5: // blink
|
|
case 4: pState->sgr.underline = BACKGROUND_INTENSITY; break;
|
|
case 7: pState->sgr.rvideo = 1; break;
|
|
case 8: pState->sgr.concealed = 1; break;
|
|
case 21: // oops, this actually turns on double underline
|
|
// but xterm turns off bold too, so that's alright
|
|
case 22: pState->sgr.bold = 0; break;
|
|
case 25:
|
|
case 24: pState->sgr.underline = 0; break;
|
|
case 27: pState->sgr.rvideo = 0; break;
|
|
case 28: pState->sgr.concealed = 0; break;
|
|
}
|
|
}
|
|
if (pState->sgr.concealed)
|
|
{
|
|
if (pState->sgr.rvideo)
|
|
{
|
|
attribut = foregroundcolor[pState->sgr.foreground]
|
|
| backgroundcolor[pState->sgr.foreground];
|
|
if (pState->sgr.bold)
|
|
attribut |= FOREGROUND_INTENSITY | BACKGROUND_INTENSITY;
|
|
}
|
|
else
|
|
{
|
|
attribut = foregroundcolor[pState->sgr.background]
|
|
| backgroundcolor[pState->sgr.background];
|
|
if (pState->sgr.underline)
|
|
attribut |= FOREGROUND_INTENSITY | BACKGROUND_INTENSITY;
|
|
}
|
|
}
|
|
else if (pState->sgr.rvideo)
|
|
{
|
|
attribut = foregroundcolor[pState->sgr.background]
|
|
| backgroundcolor[pState->sgr.foreground];
|
|
if (pState->sgr.bold)
|
|
attribut |= BACKGROUND_INTENSITY;
|
|
if (pState->sgr.underline)
|
|
attribut |= FOREGROUND_INTENSITY;
|
|
}
|
|
else
|
|
attribut = foregroundcolor[pState->sgr.foreground] | pState->sgr.bold
|
|
| backgroundcolor[pState->sgr.background] | pState->sgr.underline;
|
|
if (pState->sgr.reverse)
|
|
attribut = ((attribut >> 4) & 15) | ((attribut & 15) << 4);
|
|
SetConsoleTextAttribute( hConOut, attribut );
|
|
return;
|
|
|
|
case 'J': // ED
|
|
if (es_argc > 1) return; // ESC[J == ESC[0J
|
|
switch (es_argv[0])
|
|
{
|
|
case 0: // ESC[0J erase from cursor to end of display
|
|
len = (bottom - CUR.Y) * WIDTH + WIDTH - CUR.X;
|
|
FillBlank( len, CUR );
|
|
return;
|
|
|
|
case 1: // ESC[1J erase from start to cursor.
|
|
Pos.X = LEFT;
|
|
Pos.Y = top;
|
|
len = (CUR.Y - top) * WIDTH + CUR.X + 1;
|
|
FillBlank( len, Pos );
|
|
return;
|
|
|
|
case 2: // ESC[2J Clear screen and home cursor
|
|
if (suffix2 != '+' && (TOP != screen_top || CUR.Y == LAST))
|
|
{
|
|
// Rather than clearing the existing window, make the current
|
|
// line the new top of the window (assuming this is the first
|
|
// thing a program does).
|
|
int range = BOTTOM - TOP;
|
|
if (CUR.Y + range < HEIGHT)
|
|
{
|
|
TOP = CUR.Y;
|
|
BOTTOM = TOP + range;
|
|
}
|
|
else
|
|
{
|
|
BOTTOM = LAST;
|
|
TOP = BOTTOM - range;
|
|
Rect.Left = LEFT;
|
|
Rect.Right = RIGHT;
|
|
Rect.Top = CUR.Y - TOP;
|
|
Rect.Bottom = CUR.Y - 1;
|
|
Pos.X = Pos.Y = 0;
|
|
CharInfo.Char.UnicodeChar = ' ';
|
|
CharInfo.Attributes = ATTR;
|
|
ScrollConsoleScreenBuffer(hConOut, &Rect, NULL, Pos, &CharInfo);
|
|
}
|
|
SetConsoleWindowInfo( hConOut, TRUE, &WIN );
|
|
screen_top = TOP;
|
|
top = TOP;
|
|
bottom = BOTTOM;
|
|
}
|
|
Pos.X = LEFT;
|
|
Pos.Y = top;
|
|
len = (bottom - top + 1) * WIDTH;
|
|
FillBlank( len, Pos );
|
|
// Not technically correct, but perhaps expected.
|
|
set_pos( Pos.X, Pos.Y );
|
|
return;
|
|
}
|
|
return;
|
|
|
|
case 'K': // EL
|
|
if (es_argc > 1) return; // ESC[K == ESC[0K
|
|
switch (es_argv[0])
|
|
{
|
|
case 0: // ESC[0K Clear to end of line
|
|
len = WIDTH - CUR.X;
|
|
FillBlank( len, CUR );
|
|
return;
|
|
|
|
case 1: // ESC[1K Clear from start of line to cursor
|
|
Pos.X = LEFT;
|
|
Pos.Y = CUR.Y;
|
|
FillBlank( CUR.X + 1, Pos );
|
|
return;
|
|
|
|
case 2: // ESC[2K Clear whole line.
|
|
Pos.X = LEFT;
|
|
Pos.Y = CUR.Y;
|
|
FillBlank( WIDTH, Pos );
|
|
return;
|
|
}
|
|
return;
|
|
|
|
case 'X': // ECH - ESC[#X Erase # characters.
|
|
if (es_argc > 1) return; // ESC[X == ESC[1X
|
|
FillBlank( p1, CUR );
|
|
return;
|
|
|
|
case 'r': // DECSTBM - ESC[#;#r Set top and bottom margins.
|
|
if (es_argc == 0 && suffix2 == '+')
|
|
{
|
|
pState->tb_margins = FALSE; // ESC[+r == remove margins
|
|
return;
|
|
}
|
|
if (es_argc > 2) return;
|
|
if (es_argv[1] == 0) es_argv[1] = BOTTOM - TOP + 1;
|
|
pState->top_margin = p1 - 1;
|
|
pState->bot_margin = es_argv[1] - 1;
|
|
if (pState->bot_margin > BOTTOM - TOP)
|
|
pState->bot_margin = BOTTOM - TOP;
|
|
if (pState->top_margin >= pState->bot_margin)
|
|
return; // top must be less than bottom
|
|
pState->tb_margins = TRUE;
|
|
set_pos( LEFT, pState->om ? TOP + pState->top_margin : TOP );
|
|
return;
|
|
|
|
case 'S': // SU - ESC[#S Scroll up/Pan down.
|
|
case 'T': // SD - ESC[#T Scroll down/Pan up.
|
|
if (es_argc > 1) return; // ESC[S == ESC[1S
|
|
Pos.X =
|
|
Rect.Left = LEFT;
|
|
Rect.Right = RIGHT;
|
|
if (pState->tb_margins)
|
|
{
|
|
Rect.Top = TOP + pState->top_margin;
|
|
Rect.Bottom = TOP + pState->bot_margin;
|
|
}
|
|
else
|
|
{
|
|
Rect.Top = top;
|
|
Rect.Bottom = bottom;
|
|
}
|
|
Pos.Y = Rect.Top + (suffix == 'T' ? p1 : -p1);
|
|
CharInfo.Char.UnicodeChar = ' ';
|
|
CharInfo.Attributes = ATTR;
|
|
ScrollConsoleScreenBuffer( hConOut, &Rect, &Rect, Pos, &CharInfo );
|
|
return;
|
|
|
|
case 'L': // IL - ESC[#L Insert # blank lines.
|
|
case 'M': // DL - ESC[#M Delete # lines.
|
|
if (es_argc > 1) return; // ESC[L == ESC[1L
|
|
Pos.X =
|
|
Rect.Left = LEFT;
|
|
Rect.Right = RIGHT;
|
|
Rect.Top = CUR.Y;
|
|
if (pState->tb_margins)
|
|
{
|
|
if (CUR.Y < TOP + pState->top_margin ||
|
|
CUR.Y > TOP + pState->bot_margin) return;
|
|
Rect.Bottom = TOP + pState->bot_margin;
|
|
}
|
|
else
|
|
{
|
|
Rect.Bottom = bottom;
|
|
}
|
|
Pos.Y = Rect.Top + (suffix == 'L' ? p1 : -p1);
|
|
CharInfo.Char.UnicodeChar = ' ';
|
|
CharInfo.Attributes = ATTR;
|
|
ScrollConsoleScreenBuffer( hConOut, &Rect, &Rect, Pos, &CharInfo );
|
|
// Technically should home the cursor, but perhaps not expected.
|
|
return;
|
|
|
|
case '@': // ICH - ESC[#@ Insert # blank characters.
|
|
case 'P': // DCH - ESC[#P Delete # characters.
|
|
if (es_argc > 1) return; // ESC[P == ESC[1P
|
|
Rect.Left = CUR.X;
|
|
Rect.Right = RIGHT;
|
|
Rect.Top =
|
|
Rect.Bottom = CUR.Y;
|
|
if (suffix == '@')
|
|
CUR.X += p1;
|
|
else
|
|
CUR.X -= p1;
|
|
CharInfo.Char.UnicodeChar = ' ';
|
|
CharInfo.Attributes = ATTR;
|
|
ScrollConsoleScreenBuffer( hConOut, &Rect, &Rect, CUR, &CharInfo );
|
|
return;
|
|
|
|
case 'k': // VPB - ESC[#k
|
|
case 'A': // CUU - ESC[#A Moves cursor up # lines
|
|
case 'F': // CPL - ESC[#F Moves cursor up # lines, column 1.
|
|
if (es_argc > 1) return; // ESC[A == ESC[1A
|
|
Pos.Y = CUR.Y - p1;
|
|
if (pState->tb_margins && (pState->om ||
|
|
CUR.Y >= TOP + pState->top_margin))
|
|
top = TOP + pState->top_margin;
|
|
if (Pos.Y < top) Pos.Y = top;
|
|
set_pos( (suffix == 'F') ? LEFT : CUR.X, Pos.Y );
|
|
return;
|
|
|
|
case 'e': // VPR - ESC[#e
|
|
case 'B': // CUD - ESC[#B Moves cursor down # lines
|
|
case 'E': // CNL - ESC[#E Moves cursor down # lines, column 1.
|
|
if (es_argc > 1) return; // ESC[B == ESC[1B
|
|
Pos.Y = CUR.Y + p1;
|
|
if (pState->tb_margins && (pState->om ||
|
|
CUR.Y <= TOP + pState->bot_margin))
|
|
bottom = TOP + pState->bot_margin;
|
|
if (Pos.Y > bottom) Pos.Y = bottom;
|
|
set_pos( (suffix == 'E') ? LEFT : CUR.X, Pos.Y );
|
|
return;
|
|
|
|
case 'a': // HPR - ESC[#a
|
|
case 'C': // CUF - ESC[#C Moves cursor forward # spaces
|
|
if (es_argc > 1) return; // ESC[C == ESC[1C
|
|
Pos.X = CUR.X + p1;
|
|
if (Pos.X > RIGHT) Pos.X = RIGHT;
|
|
set_pos( Pos.X, CUR.Y );
|
|
return;
|
|
|
|
case 'j': // HPB - ESC[#j
|
|
case 'D': // CUB - ESC[#D Moves cursor back # spaces
|
|
if (es_argc > 1) return; // ESC[D == ESC[1D
|
|
cub:
|
|
Pos.X = CUR.X - p1;
|
|
while (Pos.X < LEFT && nWrapped-- && CUR.Y != top)
|
|
{
|
|
Pos.X += WIDTH;
|
|
CUR.Y--;
|
|
}
|
|
if (Pos.X < LEFT) Pos.X = LEFT;
|
|
set_pos( Pos.X, CUR.Y );
|
|
return;
|
|
|
|
case '`': // HPA - ESC[#`
|
|
case 'G': // CHA - ESC[#G Moves cursor column # in current row.
|
|
if (es_argc > 1) return; // ESC[G == ESC[1G
|
|
Pos.X = p1 - 1;
|
|
if (Pos.X > RIGHT) Pos.X = RIGHT;
|
|
set_pos( Pos.X, CUR.Y );
|
|
return;
|
|
|
|
case 'f': // HVP - ESC[#;#f
|
|
case 'H': // CUP - ESC[#;#H Moves cursor to line #, column #
|
|
if (es_argc > 2) return; // ESC[H == ESC[1;1H ESC[#H == ESC[#;1H
|
|
CUR.X = p2 - 1;
|
|
if (CUR.X > RIGHT) CUR.X = RIGHT;
|
|
--es_argc; // so we can fall through
|
|
|
|
case 'd': // VPA - ESC[#d Moves cursor row #, current column.
|
|
if (es_argc > 1) return; // ESC[d == ESC[1d
|
|
if (pState->tb_margins && pState->om)
|
|
{
|
|
top = TOP + pState->top_margin;
|
|
bottom = TOP + pState->bot_margin;
|
|
}
|
|
Pos.Y = top + p1 - 1;
|
|
if (Pos.Y < top) Pos.Y = top;
|
|
if (Pos.Y > bottom) Pos.Y = bottom;
|
|
set_pos( CUR.X, Pos.Y );
|
|
return;
|
|
|
|
case 'g': // TBC
|
|
if (es_argc > 1) return; // ESC[g == ESC[0g
|
|
switch (es_argv[0])
|
|
{
|
|
case 0: // ESC[0g Clear tab at cursor
|
|
if (!pState->tabs) init_tabs( 8 );
|
|
if (CUR.X < MAX_TABS) pState->tab_stop[CUR.X] = FALSE;
|
|
return;
|
|
|
|
case 3: // ESC[3g Clear all tabs
|
|
memset( pState->tab_stop, FALSE, MAX_TABS );
|
|
pState->tabs = TRUE;
|
|
return;
|
|
|
|
case 8: // ESC[8g Let console handle tabs
|
|
pState->tabs = FALSE;
|
|
return;
|
|
}
|
|
return;
|
|
|
|
case 'I': // CHT - ESC[#I Moves cursor forward # tabs
|
|
if (es_argc > 1) return; // ESC[I == ESC[1I
|
|
Pos.Y = CUR.Y;
|
|
if (pState->tabs)
|
|
{
|
|
Pos.X = CUR.X;
|
|
while (++Pos.X < MAX_TABS && (!pState->tab_stop[Pos.X] || --p1 > 0)) ;
|
|
}
|
|
else
|
|
Pos.X = (CUR.X & -8) + p1 * 8;
|
|
if (Pos.X > RIGHT) Pos.X = RIGHT;
|
|
// Don't use set_pos, the tabs could be discarded.
|
|
SetConsoleCursorPosition( hConOut, Pos );
|
|
return;
|
|
|
|
case 'Z': // CBT - ESC[#Z Moves cursor back # tabs
|
|
if (es_argc > 1) return; // ESC[Z == ESC[1Z
|
|
if (pState->tabs)
|
|
{
|
|
Pos.X = (CUR.X < MAX_TABS) ? CUR.X : MAX_TABS;
|
|
while (--Pos.X > 0 && (!pState->tab_stop[Pos.X] || --p1 > 0)) ;
|
|
}
|
|
else
|
|
{
|
|
if ((CUR.X & 7) == 0)
|
|
Pos.X = CUR.X - p1 * 8;
|
|
else
|
|
Pos.X = (CUR.X & -8) - (p1 - 1) * 8;
|
|
if (Pos.X < LEFT) Pos.X = LEFT;
|
|
}
|
|
set_pos( Pos.X, CUR.Y );
|
|
return;
|
|
|
|
case 'b': // REP - ESC[#b Repeat character
|
|
if (es_argc > 1) return; // ESC[b == ESC[1b
|
|
if (ChPrev == '\b') goto cub;
|
|
while (--p1 >= 0)
|
|
PushBuffer( ChPrev );
|
|
return;
|
|
|
|
case 's': // SCOSC - ESC[s Saves cursor position for recall later
|
|
if (es_argc != 0) return;
|
|
pState->SavePos = CUR;
|
|
return;
|
|
|
|
case 'u': // SCORC - ESC[u Return to saved cursor position
|
|
if (es_argc != 0) return;
|
|
Pos = pState->SavePos;
|
|
if (Pos.X > RIGHT) Pos.X = RIGHT;
|
|
if (Pos.Y > LAST) Pos.Y = LAST;
|
|
set_pos( Pos.X, Pos.Y );
|
|
return;
|
|
|
|
case 'c': // DA - ESC[#c Device attributes
|
|
if (es_argc > 1 || es_argv[0] != 0) return; // ESC[c == ESC[0c
|
|
SendSequence( L"\33[?62;1c" ); // VT220 with 132 columns
|
|
return;
|
|
|
|
case 'n': // DSR - ESC[#n Device status report
|
|
if (es_argc != 1) return; // ESC[n == ESC[0n -> ignored
|
|
switch (es_argv[0])
|
|
{
|
|
case 5: // ESC[5n Report status
|
|
SendSequence( L"\33[0n" ); // "OK"
|
|
return;
|
|
|
|
case 6: // ESC[6n Report cursor position
|
|
{
|
|
TCHAR buf[32];
|
|
wsprintf( buf, L"\33[%d;%d%sR",
|
|
CUR.Y - top + 1, CUR.X + 1,
|
|
(suffix2 == '+') ? L"+" : L"" );
|
|
SendSequence( buf );
|
|
}
|
|
return;
|
|
}
|
|
return;
|
|
|
|
case 't': // ESC[#t Window manipulation
|
|
if (es_argc != 1) return;
|
|
if (es_argv[0] == 21) // ESC[21t Report xterm window's title
|
|
{
|
|
TCHAR buf[MAX_PATH*2];
|
|
DWORD len = GetConsoleTitle( buf+3, lenof(buf)-3-2 );
|
|
// Too bad if it's too big or fails.
|
|
buf[0] = ESC;
|
|
buf[1] = ']';
|
|
buf[2] = 'l';
|
|
buf[3+len] = ESC;
|
|
buf[3+len+1] = '\\';
|
|
buf[3+len+2] = '\0';
|
|
SendSequence( buf );
|
|
}
|
|
return;
|
|
|
|
case 'h': // SM - ESC[#...h Set Mode
|
|
case 'l': // RM - ESC[#...l Reset Mode
|
|
{
|
|
BOOL state = (suffix == 'h');
|
|
for (i = 0; i < es_argc; i++)
|
|
if (suffix2 == '+') switch (es_argv[i])
|
|
{
|
|
case 1: // ACFM
|
|
pState->fm = state;
|
|
break;
|
|
}
|
|
else switch (es_argv[i])
|
|
{
|
|
case 3: // CRM
|
|
pState->crm = state;
|
|
break;
|
|
|
|
case 4: // IRM
|
|
im = state;
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
default:
|
|
return;
|
|
}
|
|
if (suffix2 == '!') switch (suffix)
|
|
{
|
|
case 'p': // DECSTR - ESC[!p Soft reset
|
|
if (es_argc != 0) return;
|
|
Reset( FALSE );
|
|
return;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
if (suffix2 == ',') switch (suffix)
|
|
{
|
|
case '~': // DECPS - ESC[#;#;#...,~ Play Sound
|
|
{
|
|
// Frequencies of notes obtained from:
|
|
// https://pages.mtu.edu/~suits/notefreqs.html
|
|
// http://www.liutaiomottola.com/formulae/freqtab.htm
|
|
// This is different to what the VT520 manual has, but since that
|
|
// only specifies four frequencies, so be it. I've also rounded to
|
|
// even numbers, as the Beep function seems to stutter on odd.
|
|
static const DWORD snd_freq[] = { 0,
|
|
// C C#/Db D D#/Eb E F F#/Gb G G#/Ab A A#/Bb B
|
|
/* 5 */ 524, 554, 588, 622, 660, 698, 740, 784, 830, 880, 932, 988,
|
|
/* 6 */ 1046, 1108, 1174, 1244, 1318, 1396, 1480, 1568, 1662, 1760, 1864, 1976,
|
|
/* 7 */ 2094
|
|
};
|
|
DWORD dur;
|
|
if (es_argc < 2) return;
|
|
dur = es_argv[1];
|
|
if (dur <= 48) // use 1/32 second
|
|
dur = 1000 * dur / 32;
|
|
else if (dur > 8000) // max out at 8 seconds
|
|
dur = 8000;
|
|
if (es_argc == 2) // no notes
|
|
Sleep( dur );
|
|
else for (i = 2; i < es_argc; ++i)
|
|
{
|
|
if (es_argv[0] == 0) // zero volume
|
|
Sleep( dur );
|
|
else
|
|
Beep( (es_argv[i] < lenof(snd_freq)) ? snd_freq[es_argv[i]]
|
|
: es_argv[i], dur );
|
|
}
|
|
return;
|
|
}
|
|
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
else // (prefix == ']')
|
|
{
|
|
// Ignore any "private" sequences.
|
|
if (prefix2 != 0 || es_argc != 1)
|
|
return;
|
|
|
|
if (es_argv[0] == 0 || // ESC]0;titleST - icon (ignored) &
|
|
es_argv[0] == 2) // ESC]2;titleST - window
|
|
{
|
|
SetConsoleTitle( Pt_arg );
|
|
}
|
|
else if (es_argv[0] == 4 || // ESC]4;paletteST - set/get color(s)
|
|
es_argv[0] == 104) // ESC]104;paletteST - reset color(s)
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFOX csbix;
|
|
csbix.cbSize = sizeof(csbix);
|
|
if (!GetConsoleScreenBufferInfoX ||
|
|
!GetConsoleScreenBufferInfoX( hConOut, &csbix ))
|
|
return;
|
|
if (es_argv[0] == 4)
|
|
{
|
|
BYTE r, g, b;
|
|
DWORD c;
|
|
LPTSTR beg, end;
|
|
BOOL started = FALSE;
|
|
for (beg = Pt_arg;; beg = end + 1)
|
|
{
|
|
i = (int)wcstoul( beg, &end, 10 );
|
|
if (end == beg || (*end != ';' && *end != '\0') || i >= 16)
|
|
break;
|
|
if (end[2] == ';' || end[2] == '\0')
|
|
{
|
|
if (end[1] == '*')
|
|
{
|
|
SendSequence( L"\33]4;" );
|
|
end[1] = '\0';
|
|
SendSequence( beg );
|
|
for (; i < 16; ++i)
|
|
{
|
|
send_palette_sequence( csbix.ColorTable[attr2ansi[i]] );
|
|
SendSequence( (i == 15) ? L"\a" : L"," );
|
|
}
|
|
}
|
|
else if (end[1] == '?')
|
|
{
|
|
if (!started)
|
|
{
|
|
SendSequence( L"\33]4" );
|
|
started = TRUE;
|
|
}
|
|
SendSequence( L";" );
|
|
end[1] = '\0';
|
|
SendSequence( beg );
|
|
send_palette_sequence( csbix.ColorTable[attr2ansi[i]] );
|
|
}
|
|
else
|
|
break;
|
|
end += (end[2] == '\0') ? 1 : 2;
|
|
}
|
|
else
|
|
{
|
|
if (started)
|
|
{
|
|
started = FALSE;
|
|
SendSequence( L"\a" );
|
|
}
|
|
for (beg = end + 1;; beg = end + 1)
|
|
{
|
|
BOOL valid;
|
|
if (*beg == '#')
|
|
{
|
|
valid = TRUE;
|
|
c = (DWORD)wcstoul( ++beg, &end, 16 );
|
|
if (end - beg == 3)
|
|
{
|
|
r = (BYTE)(c >> 8);
|
|
g = (BYTE)(c >> 4) & 0xF;
|
|
b = (BYTE)c & 0xF;
|
|
r |= r << 4;
|
|
g |= g << 4;
|
|
b |= b << 4;
|
|
}
|
|
else if (end - beg == 6)
|
|
{
|
|
r = (BYTE)(c >> 16);
|
|
g = (BYTE)(c >> 8);
|
|
b = (BYTE)c;
|
|
}
|
|
else
|
|
valid = FALSE;
|
|
}
|
|
else if (wcsncmp( beg, L"rgb:", 4 ) == 0)
|
|
{
|
|
valid = FALSE;
|
|
c = (DWORD)wcstoul( beg += 4, &end, 16 );
|
|
if (*end == '/' && (end - beg == 2 || end - beg == 4))
|
|
{
|
|
r = (BYTE)(end - beg == 2 ? c : c >> 8);
|
|
c = (DWORD)wcstoul( beg = end + 1, &end, 16 );
|
|
if (*end == '/' && (end - beg == 2 || end - beg == 4))
|
|
{
|
|
g = (BYTE)(end - beg == 2 ? c : c >> 8);
|
|
c = (DWORD)wcstoul( beg = end + 1, &end, 16 );
|
|
if ((*end == ',' || *end == ';' || *end == '\0') &&
|
|
(end - beg == 2 || end - beg == 4))
|
|
{
|
|
b = (BYTE)(end - beg == 2 ? c : c >> 8);
|
|
valid = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
valid = FALSE;
|
|
c = (DWORD)wcstoul( beg, &end, 10 );
|
|
if (*end == ',' && c < 256)
|
|
{
|
|
r = (BYTE)c;
|
|
c = (DWORD)wcstoul( end + 1, &end, 10 );
|
|
if (*end == ',' && c < 256)
|
|
{
|
|
g = (BYTE)c;
|
|
c = (DWORD)wcstoul( end + 1, &end, 10 );
|
|
if ((*end == ',' || *end == ';' || *end == '\0') && c < 256)
|
|
{
|
|
b = (BYTE)c;
|
|
valid = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (valid)
|
|
csbix.ColorTable[attr2ansi[i++]] = RGB( r, g, b );
|
|
if (*end != ',' || i == 16)
|
|
{
|
|
while (*end != ';' && *end != '\0')
|
|
++end;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (*end != ';')
|
|
break;
|
|
}
|
|
if (started)
|
|
SendSequence( L"\a" );
|
|
}
|
|
else // (es_argv[0] == 104)
|
|
{
|
|
// Reset each index, or the entire palette.
|
|
if (Pt_len == 0)
|
|
memcpy( csbix.ColorTable, pState->palette, sizeof(csbix.ColorTable) );
|
|
else
|
|
{
|
|
LPTSTR beg, end;
|
|
for (beg = Pt_arg;; beg = end + 1)
|
|
{
|
|
i = (int)wcstoul( beg, &end, 10 );
|
|
if (end == beg || (*end != ';' && *end != '\0') || i >= 16)
|
|
break;
|
|
i = attr2ansi[i];
|
|
csbix.ColorTable[i] = pState->palette[i];
|
|
if (*end == '\0')
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
++csbix.srWindow.Right;
|
|
++csbix.srWindow.Bottom;
|
|
SetConsoleScreenBufferInfoX( hConOut, &csbix );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void MoveDown( BOOL home )
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO Info;
|
|
SMALL_RECT Rect;
|
|
COORD Pos;
|
|
CHAR_INFO CharInfo;
|
|
|
|
GetConsoleScreenBufferInfo( hConOut, &Info );
|
|
if (pState->tb_margins && CUR.Y == TOP + pState->bot_margin)
|
|
{
|
|
Rect.Left = LEFT;
|
|
Rect.Right = RIGHT;
|
|
Rect.Top = TOP + pState->top_margin + 1;
|
|
Rect.Bottom = TOP + pState->bot_margin;
|
|
Pos.X = LEFT;
|
|
Pos.Y = TOP + pState->top_margin;
|
|
CharInfo.Char.UnicodeChar = ' ';
|
|
CharInfo.Attributes = ATTR;
|
|
ScrollConsoleScreenBuffer( hConOut, &Rect, NULL, Pos, &CharInfo );
|
|
if (home)
|
|
{
|
|
CUR.X = 0;
|
|
SetConsoleCursorPosition( hConOut, CUR );
|
|
}
|
|
}
|
|
else if (pState->tb_margins && CUR.Y == BOTTOM)
|
|
{
|
|
if (home)
|
|
{
|
|
CUR.X = 0;
|
|
SetConsoleCursorPosition( hConOut, CUR );
|
|
}
|
|
}
|
|
else if (CUR.Y == LAST)
|
|
{
|
|
Rect.Left = LEFT;
|
|
Rect.Right = RIGHT;
|
|
Rect.Top = 1;
|
|
Rect.Bottom = LAST;
|
|
Pos.X = Pos.Y = 0;
|
|
CharInfo.Char.UnicodeChar = ' ';
|
|
CharInfo.Attributes = ATTR;
|
|
ScrollConsoleScreenBuffer( hConOut, &Rect, NULL, Pos, &CharInfo );
|
|
if (home)
|
|
{
|
|
CUR.X = 0;
|
|
SetConsoleCursorPosition( hConOut, CUR );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (home) CUR.X = 0;
|
|
++CUR.Y;
|
|
SetConsoleCursorPosition( hConOut, CUR );
|
|
}
|
|
}
|
|
|
|
void MoveUp( void )
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO Info;
|
|
SMALL_RECT Rect;
|
|
COORD Pos;
|
|
CHAR_INFO CharInfo;
|
|
|
|
GetConsoleScreenBufferInfo( hConOut, &Info );
|
|
if (pState->tb_margins && CUR.Y == TOP + pState->top_margin)
|
|
{
|
|
Rect.Left = LEFT;
|
|
Rect.Right = RIGHT;
|
|
Rect.Top = TOP + pState->top_margin;
|
|
Rect.Bottom = TOP + pState->bot_margin - 1;
|
|
Pos.X = LEFT;
|
|
Pos.Y = TOP + pState->top_margin + 1;
|
|
CharInfo.Char.UnicodeChar = ' ';
|
|
CharInfo.Attributes = ATTR;
|
|
ScrollConsoleScreenBuffer( hConOut, &Rect, NULL, Pos, &CharInfo );
|
|
}
|
|
else if (pState->tb_margins && CUR.Y == TOP)
|
|
{
|
|
// do nothing
|
|
}
|
|
else if (CUR.Y == 0)
|
|
{
|
|
Rect.Left = LEFT;
|
|
Rect.Right = RIGHT;
|
|
Rect.Top = 0;
|
|
Rect.Bottom = LAST - 1;
|
|
Pos.X = LEFT;
|
|
Pos.Y = 1;
|
|
CharInfo.Char.UnicodeChar = ' ';
|
|
CharInfo.Attributes = ATTR;
|
|
ScrollConsoleScreenBuffer( hConOut, &Rect, NULL, Pos, &CharInfo );
|
|
}
|
|
else
|
|
{
|
|
--CUR.Y;
|
|
SetConsoleCursorPosition( hConOut, CUR );
|
|
}
|
|
}
|
|
|
|
|
|
DWORD WINAPI FlushThread( LPVOID param )
|
|
{
|
|
for (;;)
|
|
{
|
|
WaitForSingleObject( hFlushTimer, INFINITE );
|
|
EnterCriticalSection( &CritSect );
|
|
FlushBuffer();
|
|
LeaveCriticalSection( &CritSect );
|
|
}
|
|
}
|
|
|
|
|
|
DWORD WINAPI BellThread( LPVOID param )
|
|
{
|
|
// XP doesn't support SND_SENTRY, so if it fails, try without.
|
|
if (!PlaySound( (LPTSTR)SND_ALIAS_SYSTEMDEFAULT, NULL,
|
|
SND_SENTRY | SND_ALIAS_ID | SND_SYNC ))
|
|
PlaySound( (LPTSTR)SND_ALIAS_SYSTEMDEFAULT, NULL, SND_ALIAS_ID | SND_SYNC );
|
|
CloseHandle( hBell );
|
|
hBell = NULL;
|
|
return 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// ParseAndPrintString(hDev, lpBuffer, nNumberOfBytesToWrite)
|
|
// Parses the string lpBuffer, interprets the escapes sequences and prints the
|
|
// characters in the device hDev (console).
|
|
// The lexer is a three states automata.
|
|
// If the number of arguments es_argc > MAX_ARG, only the MAX_ARG-1 firsts and
|
|
// the last arguments are processed (no es_argv[] overflow).
|
|
//-----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
ParseAndPrintString( HANDLE hDev,
|
|
LPCVOID lpBuffer,
|
|
DWORD nNumberOfBytesToWrite,
|
|
LPDWORD lpNumberOfBytesWritten
|
|
)
|
|
{
|
|
DWORD i;
|
|
LPCTSTR s;
|
|
|
|
EnterCriticalSection( &CritSect );
|
|
|
|
if (hDev != hConOut) // reinit if device has changed
|
|
{
|
|
FlushBuffer();
|
|
hConOut = hDev;
|
|
state = 1;
|
|
im = shifted = G0_special = FALSE;
|
|
}
|
|
for (i = nNumberOfBytesToWrite, s = (LPCTSTR)lpBuffer; i > 0; i--, s++)
|
|
{
|
|
int c = *s; // more efficient to use int than short, fwiw
|
|
|
|
if (state == 1)
|
|
{
|
|
if (c == ESC)
|
|
{
|
|
suffix2 = 0;
|
|
ibytes = 0;
|
|
get_state();
|
|
state = (pState->crm) ? 7 : 2;
|
|
}
|
|
else if (pState->crm) PushBuffer( (WCHAR)c );
|
|
else if (c == BEL)
|
|
{
|
|
if (hBell == NULL)
|
|
hBell = CreateThread( NULL, 4096, BellThread, NULL, 0, NULL );
|
|
}
|
|
else if (c == SO) shifted = TRUE;
|
|
else if (c == SI) shifted = G0_special;
|
|
else if (c == HT && pState->tabs)
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO Info;
|
|
FlushBuffer();
|
|
GetConsoleScreenBufferInfo( hConOut, &Info );
|
|
while (++CUR.X < MAX_TABS && !pState->tab_stop[CUR.X]) ;
|
|
if (CUR.X > RIGHT) CUR.X = RIGHT;
|
|
// Don't use set_pos, the tab could be discarded.
|
|
SetConsoleCursorPosition( hConOut, CUR );
|
|
}
|
|
else if (im && (c == HT || c == '\r' || c == '\b' || c == '\n'))
|
|
{
|
|
FlushBuffer();
|
|
im = FALSE;
|
|
PushBuffer( (WCHAR)c );
|
|
FlushBuffer();
|
|
im = TRUE;
|
|
}
|
|
else PushBuffer( (WCHAR)c );
|
|
}
|
|
else if (state == 2)
|
|
{
|
|
if (c < '\x20')
|
|
{
|
|
FlushBuffer();
|
|
pState->crm = TRUE;
|
|
ChBuffer[nCharInBuffer++] = c; // skip newline handling
|
|
FlushBuffer();
|
|
pState->crm = FALSE;
|
|
state = 1;
|
|
}
|
|
else if (c >= '\x20' && c <= '\x2f')
|
|
{
|
|
suffix2 = c;
|
|
++ibytes;
|
|
}
|
|
else if (ibytes != 0)
|
|
{
|
|
if (ibytes == 1 &&
|
|
suffix2 == '(') // SCS - Designate G0 character set
|
|
{
|
|
if (c == '0')
|
|
shifted = G0_special = TRUE;
|
|
else if (c == 'B')
|
|
shifted = G0_special = FALSE;
|
|
}
|
|
state = 1;
|
|
}
|
|
else if (c == 'E') // NEL Next Line
|
|
{
|
|
PushBuffer( '\n' );
|
|
state = 1;
|
|
}
|
|
else if (c == 'D') // IND Index
|
|
{
|
|
FlushBuffer();
|
|
MoveDown( FALSE );
|
|
state = 1;
|
|
}
|
|
else if (c == 'M') // RI Reverse Index
|
|
{
|
|
FlushBuffer();
|
|
MoveUp();
|
|
state = 1;
|
|
}
|
|
else if (c == 'H') // HTS Character Tabulation Set
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO Info;
|
|
if (!pState->tabs) init_tabs( 8 );
|
|
FlushBuffer();
|
|
GetConsoleScreenBufferInfo( hConOut, &Info );
|
|
if (CUR.X < MAX_TABS) pState->tab_stop[CUR.X] = TRUE;
|
|
state = 1;
|
|
}
|
|
else if (c == '7') // DECSC Save Cursor
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO Info;
|
|
FlushBuffer();
|
|
GetConsoleScreenBufferInfo( hConOut, &Info );
|
|
pState->SavePos = CUR;
|
|
pState->SaveSgr = pState->sgr;
|
|
pState->SaveAttr = ATTR;
|
|
SaveG0 = G0_special;
|
|
state = 1;
|
|
}
|
|
else if (c == '8') // DECRC Restore Cursor
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO Info;
|
|
FlushBuffer();
|
|
GetConsoleScreenBufferInfo( hConOut, &Info );
|
|
CUR = pState->SavePos;
|
|
if (CUR.X > RIGHT) CUR.X = RIGHT;
|
|
if (CUR.Y > LAST) CUR.Y = LAST;
|
|
set_pos( CUR.X, CUR.Y );
|
|
if (pState->SaveAttr != 0) // assume 0 means not saved
|
|
{
|
|
pState->sgr = pState->SaveSgr;
|
|
SetConsoleTextAttribute( hConOut, pState->SaveAttr );
|
|
shifted = G0_special = SaveG0;
|
|
}
|
|
state = 1;
|
|
}
|
|
else if (c == 'c') // RIS Reset to Initial State
|
|
{
|
|
Reset( TRUE );
|
|
}
|
|
else if (c == '[' || // CSI Control Sequence Introducer
|
|
c == ']') // OSC Operating System Command
|
|
{
|
|
FlushBuffer();
|
|
prefix = c;
|
|
prefix2 = 0;
|
|
es_argc = 0;
|
|
es_argv[0] = es_argv[1] = 0;
|
|
Pt_len = 0;
|
|
*Pt_arg = '\0';
|
|
state = 3;
|
|
}
|
|
else if (c == 'P' || // DCS Device Control String
|
|
c == 'X' || // SOS Start Of String
|
|
c == '^' || // PM Privacy Message
|
|
c == '_') // APC Application Program Command
|
|
{
|
|
*Pt_arg = '\0';
|
|
state = 6;
|
|
}
|
|
else
|
|
{
|
|
PushBuffer( ESC );
|
|
PushBuffer( (WCHAR)c );
|
|
state = 1;
|
|
}
|
|
}
|
|
else if (state == 3)
|
|
{
|
|
if (is_digit( c ))
|
|
{
|
|
es_argv[0] = c - '0';
|
|
state = 4;
|
|
}
|
|
else if (c == ';')
|
|
{
|
|
es_argc = 1;
|
|
state = 4;
|
|
}
|
|
else if (c == ':')
|
|
{
|
|
// ignore it
|
|
}
|
|
else if (c >= '\x3c' && c <= '\x3f')
|
|
{
|
|
prefix2 = c;
|
|
}
|
|
else if (c >= '\x20' && c <= '\x2f')
|
|
{
|
|
suffix2 = c;
|
|
++ibytes;
|
|
}
|
|
else if (ibytes > 1)
|
|
{
|
|
state = 1;
|
|
}
|
|
else
|
|
{
|
|
es_argc = 0;
|
|
suffix = c;
|
|
InterpretEscSeq();
|
|
state = 1;
|
|
}
|
|
}
|
|
else if (state == 4)
|
|
{
|
|
if (is_digit( c ))
|
|
{
|
|
es_argv[es_argc] = 10 * es_argv[es_argc] + (c - '0');
|
|
if (es_argv[es_argc] > 32767) es_argv[es_argc] = 32767;
|
|
}
|
|
else if (c == ';')
|
|
{
|
|
if (es_argc < MAX_ARG-1) es_argc++;
|
|
es_argv[es_argc] = 0;
|
|
if (prefix == ']')
|
|
state = 5;
|
|
}
|
|
else if (c >= '\x3a' && c <= '\x3f')
|
|
{
|
|
// ignore 'em
|
|
}
|
|
else if (c >= '\x20' && c <= '\x2f')
|
|
{
|
|
suffix2 = c;
|
|
++ibytes;
|
|
}
|
|
else if (ibytes > 1)
|
|
{
|
|
state = 1;
|
|
}
|
|
else if (prefix == ']')
|
|
{
|
|
es_argc++;
|
|
state = 5;
|
|
goto state5;
|
|
}
|
|
else
|
|
{
|
|
es_argc++;
|
|
suffix = c;
|
|
InterpretEscSeq();
|
|
state = 1;
|
|
}
|
|
}
|
|
else if (state == 5)
|
|
{
|
|
state5:
|
|
if (c == BEL)
|
|
{
|
|
Pt_arg[Pt_len] = '\0';
|
|
InterpretEscSeq();
|
|
state = 1;
|
|
}
|
|
else if (c == '\\' && Pt_len > 0 && Pt_arg[Pt_len-1] == ESC)
|
|
{
|
|
Pt_arg[--Pt_len] = '\0';
|
|
InterpretEscSeq();
|
|
state = 1;
|
|
}
|
|
else if (Pt_len < lenof(Pt_arg)-1)
|
|
Pt_arg[Pt_len++] = c;
|
|
}
|
|
else if (state == 6)
|
|
{
|
|
if (c == BEL || (c == '\\' && *Pt_arg == ESC))
|
|
state = 1;
|
|
else
|
|
*Pt_arg = c;
|
|
}
|
|
else if (state == 7)
|
|
{
|
|
if (c == '[') state = 8;
|
|
else
|
|
{
|
|
PushBuffer( ESC );
|
|
if (c != ESC)
|
|
{
|
|
PushBuffer( (WCHAR)c );
|
|
state = 1;
|
|
}
|
|
}
|
|
}
|
|
else if (state == 8)
|
|
{
|
|
if (c == '3') state = 9;
|
|
else
|
|
{
|
|
PushBuffer( ESC );
|
|
PushBuffer( '[' );
|
|
PushBuffer( (WCHAR)c );
|
|
state = 1;
|
|
}
|
|
}
|
|
else if (state == 9)
|
|
{
|
|
if (c == 'l')
|
|
{
|
|
FlushBuffer();
|
|
pState->crm = FALSE;
|
|
}
|
|
else
|
|
{
|
|
PushBuffer( ESC );
|
|
PushBuffer( '[' );
|
|
PushBuffer( '3' );
|
|
PushBuffer( (WCHAR)c );
|
|
}
|
|
state = 1;
|
|
}
|
|
}
|
|
if (nCharInBuffer > 0)
|
|
{
|
|
if (pState->fm) FlushBuffer();
|
|
else
|
|
{
|
|
LARGE_INTEGER due;
|
|
due.QuadPart = -150000;
|
|
SetWaitableTimer( hFlushTimer, &due, 0, NULL, NULL, FALSE );
|
|
}
|
|
}
|
|
if (lpNumberOfBytesWritten != NULL)
|
|
*lpNumberOfBytesWritten = nNumberOfBytesToWrite - i;
|
|
|
|
LeaveCriticalSection( &CritSect );
|
|
|
|
return (i == 0);
|
|
}
|
|
|
|
|
|
// ========== Hooking API functions
|
|
//
|
|
// References about API hooking (and dll injection):
|
|
// - Matt Pietrek ~ Windows 95 System Programming Secrets.
|
|
// - Jeffrey Richter ~ Programming Applications for Microsoft Windows 4th ed.
|
|
|
|
const char APIKernel[] = "kernel32.dll";
|
|
const char APIConsole[] = "API-MS-Win-Core-Console-";
|
|
const char APIProcessThreads[] = "API-MS-Win-Core-ProcessThreads-";
|
|
const char APIProcessEnvironment[] = "API-MS-Win-Core-ProcessEnvironment-";
|
|
const char APILibraryLoader[] = "API-MS-Win-Core-LibraryLoader-";
|
|
const char APIFile[] = "API-MS-Win-Core-File-";
|
|
|
|
typedef struct
|
|
{
|
|
PCSTR name;
|
|
DWORD len;
|
|
HMODULE base;
|
|
} API_DATA, *PAPI_DATA;
|
|
|
|
API_DATA APIs[] =
|
|
{
|
|
{ APIConsole, sizeof(APIConsole) - 1, NULL },
|
|
{ APIProcessThreads, sizeof(APIProcessThreads) - 1, NULL },
|
|
{ APIProcessEnvironment, sizeof(APIProcessEnvironment) - 1, NULL },
|
|
{ APILibraryLoader, sizeof(APILibraryLoader) - 1, NULL },
|
|
{ APIFile, sizeof(APIFile) - 1, NULL },
|
|
{ NULL, 0, NULL }
|
|
};
|
|
|
|
|
|
HMODULE hKernel; // Kernel32 module handle
|
|
HINSTANCE hDllInstance; // Dll instance handle
|
|
#if defined(_WIN64) || defined(W32ON64)
|
|
LPTSTR DllNameType; // pointer to process type within DllName
|
|
#endif
|
|
|
|
typedef struct
|
|
{
|
|
PCSTR lib;
|
|
PSTR name;
|
|
PROC newfunc;
|
|
PROC oldfunc;
|
|
PROC apifunc;
|
|
PULONG_PTR myimport;
|
|
} HookFn, *PHookFn;
|
|
|
|
HookFn Hooks[];
|
|
|
|
const char zIgnoring[] = "Ignoring";
|
|
const char zScanning[] = "Scanning";
|
|
const char zSkipping[] = "Skipping";
|
|
const char zHooking[] = "Hooking";
|
|
const char zUnhooking[] = "Unhooking";
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// HookAPIOneMod
|
|
// Substitute a new function in the Import Address Table (IAT) of the
|
|
// specified module.
|
|
// Return FALSE on error and TRUE on success.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
BOOL HookAPIOneMod(
|
|
HMODULE hFromModule, // Handle of the module to intercept calls from
|
|
PHookFn Hooks, // Functions to replace
|
|
BOOL restore, // Restore the original functions
|
|
LPCSTR sp // Logging indentation
|
|
)
|
|
{
|
|
PIMAGE_DOS_HEADER pDosHeader;
|
|
PIMAGE_NT_HEADERS pNTHeader;
|
|
PIMAGE_IMPORT_DESCRIPTOR pImportDesc;
|
|
PIMAGE_THUNK_DATA pThunk;
|
|
PHookFn hook;
|
|
BOOL self;
|
|
|
|
if (hFromModule == NULL)
|
|
{
|
|
self = TRUE;
|
|
hFromModule = hDllInstance;
|
|
}
|
|
else
|
|
self = FALSE;
|
|
|
|
// Tests to make sure we're looking at a module image (the 'MZ' header)
|
|
pDosHeader = (PIMAGE_DOS_HEADER)hFromModule;
|
|
if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
|
|
{
|
|
DEBUGSTR( 1, "Image has no DOS header!" );
|
|
return FALSE;
|
|
}
|
|
|
|
// The MZ header has a pointer to the PE header
|
|
pNTHeader = MakeVA( PIMAGE_NT_HEADERS, pDosHeader->e_lfanew );
|
|
|
|
// One more test to make sure we're looking at a "PE" image
|
|
if (pNTHeader->Signature != IMAGE_NT_SIGNATURE)
|
|
{
|
|
DEBUGSTR( 1, "Image has no NT header!" );
|
|
return FALSE;
|
|
}
|
|
|
|
// We now have a valid pointer to the module's PE header.
|
|
// Get a pointer to its imports section.
|
|
pImportDesc = MakeVA( PIMAGE_IMPORT_DESCRIPTOR,
|
|
pNTHeader->IMPORTDIR.VirtualAddress );
|
|
|
|
// Bail out if the RVA of the imports section is 0 (it doesn't exist)
|
|
if (pImportDesc == (PIMAGE_IMPORT_DESCRIPTOR)pDosHeader)
|
|
return TRUE;
|
|
|
|
// Iterate through the array of imported module descriptors, looking
|
|
// for the module whose name matches the pszFunctionModule parameter.
|
|
for (; pImportDesc->Name; pImportDesc++)
|
|
{
|
|
BOOL kernel = TRUE;
|
|
PSTR pszModName = MakeVA( PSTR, pImportDesc->Name );
|
|
if (_strnicmp( pszModName, APIKernel, 8 ) != 0 ||
|
|
(_stricmp( pszModName+8, APIKernel+8 ) != 0 && pszModName[8] != '\0'))
|
|
{
|
|
PAPI_DATA lib;
|
|
for (lib = APIs; lib->name; ++lib)
|
|
{
|
|
if (_strnicmp( pszModName, lib->name, lib->len ) == 0)
|
|
{
|
|
if (lib->base == NULL)
|
|
{
|
|
lib->base = GetModuleHandleA( pszModName );
|
|
for (hook = Hooks; hook->name; ++hook)
|
|
if (hook->lib == lib->name)
|
|
hook->apifunc = GetProcAddress( lib->base, hook->name );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (lib->name == NULL)
|
|
{
|
|
if (log_level & 16)
|
|
DEBUGSTR( 2, " %s%s %s", sp, zIgnoring, pszModName );
|
|
continue;
|
|
}
|
|
kernel = FALSE;
|
|
}
|
|
if (log_level & 16)
|
|
DEBUGSTR( 2, " %s%s %s", sp, zScanning, pszModName );
|
|
|
|
// Get a pointer to the found module's import address table (IAT).
|
|
pThunk = MakeVA( PIMAGE_THUNK_DATA, pImportDesc->FirstThunk );
|
|
|
|
// Blast through the table of import addresses, looking for the ones
|
|
// that match the original addresses.
|
|
while (pThunk->u1.Function)
|
|
{
|
|
for (hook = Hooks; hook->name; ++hook)
|
|
{
|
|
PROC patch = 0;
|
|
if (restore)
|
|
{
|
|
if ((PROC)pThunk->u1.Function == hook->newfunc)
|
|
patch = (kernel) ? hook->oldfunc : hook->apifunc;
|
|
}
|
|
else if ((PROC)pThunk->u1.Function == hook->oldfunc ||
|
|
(PROC)pThunk->u1.Function == hook->apifunc)
|
|
{
|
|
if (self)
|
|
{
|
|
hook->myimport = &pThunk->u1.Function;
|
|
DEBUGSTR( 3, " %s%s", sp, hook->name );
|
|
}
|
|
else
|
|
{
|
|
// Don't hook if our import already points to the module being
|
|
// hooked (i.e. it's already hooked us).
|
|
MEMORY_BASIC_INFORMATION minfo;
|
|
VirtualQuery( (LPVOID)*hook->myimport, &minfo, sizeof(minfo) );
|
|
if (minfo.AllocationBase != hFromModule)
|
|
patch = hook->newfunc;
|
|
}
|
|
}
|
|
if (patch)
|
|
{
|
|
DWORD pr;
|
|
|
|
DEBUGSTR( 3, " %s%s", sp, hook->name );
|
|
// Change the access protection on the region of committed pages in
|
|
// the virtual address space of the current process.
|
|
VirtualProtect( &pThunk->u1.Function, PTRSZ, PAGE_READWRITE, &pr );
|
|
|
|
// Overwrite the original address with the address of the new function.
|
|
pThunk->u1.Function = (DWORD_PTR)patch;
|
|
|
|
// Put the page attributes back the way they were.
|
|
VirtualProtect( &pThunk->u1.Function, PTRSZ, pr, &pr );
|
|
}
|
|
}
|
|
pThunk++; // Advance to next imported function address
|
|
}
|
|
}
|
|
|
|
return TRUE; // Function not found
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// HookAPIAllMod
|
|
// Substitute a new function in the Import Address Table (IAT) of all
|
|
// the modules in the current process.
|
|
// Return FALSE on error and TRUE on success.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
BOOL HookAPIAllMod( PHookFn Hooks, BOOL restore, BOOL indent )
|
|
{
|
|
HANDLE hModuleSnap;
|
|
MODULEENTRY32 me;
|
|
BOOL fOk;
|
|
LPCSTR op, sp;
|
|
DWORD pr;
|
|
|
|
// Take a snapshot of all modules in the current process.
|
|
hModuleSnap = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE,
|
|
GetCurrentProcessId() );
|
|
|
|
if (hModuleSnap == INVALID_HANDLE_VALUE)
|
|
{
|
|
DEBUGSTR( 1, "Failed to create snapshot (%u)", GetLastError() );
|
|
return FALSE;
|
|
}
|
|
|
|
op = (restore) ? zUnhooking : zHooking;
|
|
sp = (indent) ? " " : "";
|
|
|
|
// Fill the size of the structure before using it.
|
|
me.dwSize = sizeof(MODULEENTRY32);
|
|
|
|
// Walk the module list of the modules.
|
|
for (fOk = Module32First( hModuleSnap, &me ); fOk;
|
|
fOk = Module32Next( hModuleSnap, &me ))
|
|
{
|
|
// We don't hook functions in our own module.
|
|
if (me.hModule == hDllInstance || me.hModule == hKernel)
|
|
continue;
|
|
|
|
if (!restore)
|
|
{
|
|
// Don't scan what we've already scanned.
|
|
if (*(PDWORD)((PBYTE)me.hModule + 36) == 'ISNA') // e_oemid, e_oeminfo
|
|
{
|
|
if (log_level & 16)
|
|
DEBUGSTR( 2, "%s%s %S", sp, zSkipping, me.szModule );
|
|
continue;
|
|
}
|
|
// It's possible for the PE header to be inside the DOS header.
|
|
if (*(PDWORD)((PBYTE)me.hModule + 0x3C) >= 0x40)
|
|
{
|
|
VirtualProtect( (PBYTE)me.hModule + 36, 4, PAGE_READWRITE, &pr );
|
|
*(PDWORD)((PBYTE)me.hModule + 36) = 'ISNA';
|
|
VirtualProtect( (PBYTE)me.hModule + 36, 4, pr, &pr );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (*(PDWORD)((PBYTE)me.hModule + 36) == 'ISNA')
|
|
{
|
|
VirtualProtect( (PBYTE)me.hModule + 36, 4, PAGE_READWRITE, &pr );
|
|
*((PBYTE)me.hModule + 36+3) = 'U';
|
|
VirtualProtect( (PBYTE)me.hModule + 36, 4, pr, &pr );
|
|
}
|
|
else if (*(PDWORD)((PBYTE)me.hModule + 0x3C) >= 0x40)
|
|
{
|
|
if (log_level & 16)
|
|
DEBUGSTR( 2, "%s%s %S", sp, zSkipping, me.szModule );
|
|
continue;
|
|
}
|
|
}
|
|
if (search_env( L"ANSICON_EXC", me.szModule ))
|
|
{
|
|
DEBUGSTR( 2, "%s%s %S", sp, zIgnoring, me.szModule );
|
|
continue;
|
|
}
|
|
|
|
// Hook the functions in this module.
|
|
DEBUGSTR( 2, "%s%s %S", sp, op, me.szModule );
|
|
if (!HookAPIOneMod( me.hModule, Hooks, restore, sp ))
|
|
{
|
|
CloseHandle( hModuleSnap );
|
|
return FALSE;
|
|
}
|
|
}
|
|
CloseHandle( hModuleSnap );
|
|
DEBUGSTR( 2, "%s%s completed", sp, op );
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// ========== Child process injection
|
|
|
|
#define MAX_DEV_PATH (32+MAX_PATH) // device form instead of drive letter
|
|
|
|
static LPTSTR get_program( LPTSTR app, HANDLE hProcess,
|
|
BOOL wide, LPCVOID lpApp, LPCVOID lpCmd )
|
|
{
|
|
app[MAX_DEV_PATH-1] = '\0';
|
|
|
|
if (lpApp == NULL)
|
|
{
|
|
typedef DWORD (WINAPI *PGPIFNW)( HANDLE, LPTSTR, DWORD );
|
|
static PGPIFNW GetProcessImageFileName;
|
|
|
|
if (GetProcessImageFileName == NULL)
|
|
{
|
|
// Use Ex to avoid potential recursion with other hooks.
|
|
HMODULE psapi = LoadLibraryEx( L"psapi.dll", NULL, 0 );
|
|
if (psapi != NULL)
|
|
{
|
|
GetProcessImageFileName = (PGPIFNW)GetProcAddress( psapi,
|
|
"GetProcessImageFileNameW" );
|
|
}
|
|
if (GetProcessImageFileName == NULL)
|
|
GetProcessImageFileName = INVALID_HANDLE_VALUE;
|
|
}
|
|
if (GetProcessImageFileName == INVALID_HANDLE_VALUE ||
|
|
GetProcessImageFileName( hProcess, app, MAX_DEV_PATH ) == 0)
|
|
{
|
|
LPTSTR name;
|
|
LPCTSTR term = L" \t";
|
|
|
|
if (wide)
|
|
{
|
|
LPCTSTR pos;
|
|
for (pos = lpCmd; *pos == ' ' || *pos == '\t'; ++pos) ;
|
|
if (*pos == '"')
|
|
{
|
|
term = L"\"";
|
|
++pos;
|
|
}
|
|
wcsncpy( app, pos, MAX_DEV_PATH-1 );
|
|
}
|
|
else
|
|
{
|
|
LPCSTR pos;
|
|
for (pos = lpCmd; *pos == ' ' || *pos == '\t'; ++pos) ;
|
|
if (*pos == '"')
|
|
{
|
|
term = L"\"";
|
|
++pos;
|
|
}
|
|
MultiByteToWideChar( CP_ACP, 0, pos, -1, app, MAX_DEV_PATH-1 );
|
|
}
|
|
// CreateProcess only works with surrounding quotes ('"a name"' works,
|
|
// but 'a" "name' fails), so that's all I'll test, too. However, it also
|
|
// tests for a file at each separator ('a name' tries "a.exe" before
|
|
// "a name.exe") which I won't do.
|
|
name = wcspbrk( app, term );
|
|
if (name != NULL)
|
|
*name = '\0';
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (wide)
|
|
wcsncpy( app, lpApp, MAX_DEV_PATH-1 );
|
|
else
|
|
MultiByteToWideChar( CP_ACP, 0, lpApp, -1, app, MAX_DEV_PATH-1 );
|
|
}
|
|
return get_program_name( app );
|
|
}
|
|
|
|
|
|
// Inject code into the target process to load our DLL.
|
|
void Inject( DWORD dwCreationFlags, LPPROCESS_INFORMATION lpi,
|
|
LPPROCESS_INFORMATION child_pi,
|
|
BOOL wide, LPCVOID lpApp, LPCVOID lpCmd )
|
|
{
|
|
int type;
|
|
PBYTE base;
|
|
BOOL gui;
|
|
WCHAR app[MAX_DEV_PATH];
|
|
LPTSTR name;
|
|
|
|
name = get_program( app, child_pi->hProcess, wide, lpApp, lpCmd );
|
|
DEBUGSTR( 1, "%S (%u)", name, child_pi->dwProcessId );
|
|
if (search_env( L"ANSICON_EXC", name ))
|
|
{
|
|
DEBUGSTR( 1, " Excluded" );
|
|
type = 0;
|
|
}
|
|
else
|
|
{
|
|
type = ProcessType( child_pi, &base, &gui );
|
|
if (gui && type > 0)
|
|
{
|
|
if (!search_env( L"ANSICON_GUI", name ))
|
|
{
|
|
DEBUGSTR( 1, " %s", zIgnoring );
|
|
type = 0;
|
|
}
|
|
}
|
|
}
|
|
if (type > 0)
|
|
{
|
|
#ifdef _WIN64
|
|
if (type == 64)
|
|
{
|
|
ansi_bits[0] = '6';
|
|
ansi_bits[1] = '4';
|
|
InjectDLL( child_pi, base );
|
|
}
|
|
else if (type == 32)
|
|
{
|
|
ansi_bits[0] = '3';
|
|
ansi_bits[1] = '2';
|
|
InjectDLL32( child_pi, base );
|
|
}
|
|
else // (type == 48)
|
|
{
|
|
InjectDLL64( child_pi );
|
|
}
|
|
#else
|
|
#ifdef W32ON64
|
|
if (type != 32)
|
|
{
|
|
TCHAR args[64];
|
|
STARTUPINFO si;
|
|
PROCESS_INFORMATION pi;
|
|
wcscpy( DllNameType, L"CON.exe" );
|
|
wsprintf( args, L"ansicon -P%ld", child_pi->dwProcessId );
|
|
ZeroMemory( &si, sizeof(si) );
|
|
si.cb = sizeof(si);
|
|
if (CreateProcess( DllName, args, NULL, NULL, FALSE, 0, NULL, NULL,
|
|
&si, &pi ))
|
|
{
|
|
WaitForSingleObject( pi.hProcess, INFINITE );
|
|
CloseHandle( pi.hProcess );
|
|
CloseHandle( pi.hThread );
|
|
}
|
|
else
|
|
DEBUGSTR( 1, "Could not execute %\"S (%u)", DllName, GetLastError() );
|
|
wcscpy( DllNameType, L"32.dll" );
|
|
}
|
|
else
|
|
#endif
|
|
InjectDLL( child_pi, base );
|
|
#endif
|
|
}
|
|
|
|
if (!(dwCreationFlags & CREATE_SUSPENDED))
|
|
ResumeThread( child_pi->hThread );
|
|
|
|
if (lpi != NULL)
|
|
{
|
|
memcpy( lpi, child_pi, sizeof(PROCESS_INFORMATION) );
|
|
}
|
|
else
|
|
{
|
|
CloseHandle( child_pi->hThread );
|
|
CloseHandle( child_pi->hProcess );
|
|
}
|
|
}
|
|
|
|
|
|
BOOL WINAPI MyCreateProcessA( LPCSTR lpApplicationName,
|
|
LPSTR lpCommandLine,
|
|
LPSECURITY_ATTRIBUTES lpThreadAttributes,
|
|
LPSECURITY_ATTRIBUTES lpProcessAttributes,
|
|
BOOL bInheritHandles,
|
|
DWORD dwCreationFlags,
|
|
LPVOID lpEnvironment,
|
|
LPCSTR lpCurrentDirectory,
|
|
LPSTARTUPINFOA lpStartupInfo,
|
|
LPPROCESS_INFORMATION lpProcessInformation )
|
|
{
|
|
PROCESS_INFORMATION child_pi;
|
|
|
|
DEBUGSTR( 1, "CreateProcessA: %\"s, %#s", lpApplicationName, lpCommandLine );
|
|
|
|
// May need to initialise the state, to propagate environment variables.
|
|
get_state();
|
|
if (!CreateProcessA( lpApplicationName,
|
|
lpCommandLine,
|
|
lpThreadAttributes,
|
|
lpProcessAttributes,
|
|
bInheritHandles,
|
|
dwCreationFlags | CREATE_SUSPENDED,
|
|
lpEnvironment,
|
|
lpCurrentDirectory,
|
|
lpStartupInfo,
|
|
&child_pi ))
|
|
{
|
|
DEBUGSTR( 1, " Failed (%u)", GetLastError() );
|
|
return FALSE;
|
|
}
|
|
|
|
Inject( dwCreationFlags, lpProcessInformation, &child_pi,
|
|
FALSE, lpApplicationName, lpCommandLine );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL WINAPI MyCreateProcessW( LPCWSTR lpApplicationName,
|
|
LPWSTR lpCommandLine,
|
|
LPSECURITY_ATTRIBUTES lpThreadAttributes,
|
|
LPSECURITY_ATTRIBUTES lpProcessAttributes,
|
|
BOOL bInheritHandles,
|
|
DWORD dwCreationFlags,
|
|
LPVOID lpEnvironment,
|
|
LPCWSTR lpCurrentDirectory,
|
|
LPSTARTUPINFOW lpStartupInfo,
|
|
LPPROCESS_INFORMATION lpProcessInformation )
|
|
{
|
|
PROCESS_INFORMATION child_pi;
|
|
|
|
DEBUGSTR( 1, "CreateProcessW: %\"S, %#S", lpApplicationName, lpCommandLine );
|
|
|
|
get_state();
|
|
if (!CreateProcessW( lpApplicationName,
|
|
lpCommandLine,
|
|
lpThreadAttributes,
|
|
lpProcessAttributes,
|
|
bInheritHandles,
|
|
dwCreationFlags | CREATE_SUSPENDED,
|
|
lpEnvironment,
|
|
lpCurrentDirectory,
|
|
lpStartupInfo,
|
|
&child_pi ))
|
|
{
|
|
DEBUGSTR( 1, " Failed (%u)", GetLastError() );
|
|
return FALSE;
|
|
}
|
|
|
|
Inject( dwCreationFlags, lpProcessInformation, &child_pi,
|
|
TRUE, lpApplicationName, lpCommandLine );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
FARPROC WINAPI MyGetProcAddress( HMODULE hModule, LPCSTR lpProcName )
|
|
{
|
|
PHookFn hook;
|
|
FARPROC proc;
|
|
|
|
proc = GetProcAddress( hModule, lpProcName );
|
|
|
|
if (proc != NULL)
|
|
{
|
|
if (hModule == hKernel)
|
|
{
|
|
// Ignore LoadLibrary so other hooks continue to work (our version
|
|
// might end up at a different address).
|
|
if (proc == Hooks[0].oldfunc || proc == Hooks[1].oldfunc)
|
|
{
|
|
DEBUGSTR( 3, "GetProcAddress: %s (ignoring)", lpProcName );
|
|
return proc;
|
|
}
|
|
for (hook = Hooks + 2; hook->name; ++hook)
|
|
{
|
|
if (proc == hook->oldfunc)
|
|
{
|
|
DEBUGSTR( 3, "GetProcAddress: %s", lpProcName );
|
|
return hook->newfunc;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PAPI_DATA api;
|
|
for (api = APIs; api->name; ++api)
|
|
{
|
|
if (hModule == api->base)
|
|
{
|
|
if (proc == Hooks[0].apifunc || proc == Hooks[1].apifunc)
|
|
{
|
|
DEBUGSTR( 3, "GetProcAddress: %s (ignoring)", lpProcName );
|
|
return proc;
|
|
}
|
|
for (hook = Hooks + 2; hook->name; ++hook)
|
|
{
|
|
if (proc == hook->apifunc)
|
|
{
|
|
DEBUGSTR( 3, "GetProcAddress: %s", lpProcName );
|
|
return hook->newfunc;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return proc;
|
|
}
|
|
|
|
|
|
HMODULE WINAPI MyLoadLibraryA( LPCSTR lpFileName )
|
|
{
|
|
HMODULE hMod = LoadLibraryA( lpFileName );
|
|
DEBUGSTR( 2, "LoadLibraryA %s", lpFileName );
|
|
HookAPIAllMod( Hooks, FALSE, TRUE );
|
|
return hMod;
|
|
}
|
|
|
|
|
|
HMODULE WINAPI MyLoadLibraryW( LPCWSTR lpFileName )
|
|
{
|
|
HMODULE hMod = LoadLibraryW( lpFileName );
|
|
DEBUGSTR( 2, "LoadLibraryW %S", lpFileName );
|
|
HookAPIAllMod( Hooks, FALSE, TRUE );
|
|
return hMod;
|
|
}
|
|
|
|
|
|
HMODULE WINAPI MyLoadLibraryExA( LPCSTR lpFileName, HANDLE hFile,
|
|
DWORD dwFlags )
|
|
{
|
|
HMODULE hMod = LoadLibraryExA( lpFileName, hFile, dwFlags );
|
|
if (!(dwFlags & (LOAD_LIBRARY_AS_DATAFILE |
|
|
LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE |
|
|
LOAD_LIBRARY_AS_IMAGE_RESOURCE)))
|
|
{
|
|
DEBUGSTR( 2, "LoadLibraryExA %s", lpFileName );
|
|
HookAPIAllMod( Hooks, FALSE, TRUE );
|
|
}
|
|
return hMod;
|
|
}
|
|
|
|
|
|
HMODULE WINAPI MyLoadLibraryExW( LPCWSTR lpFileName, HANDLE hFile,
|
|
DWORD dwFlags )
|
|
{
|
|
HMODULE hMod = LoadLibraryExW( lpFileName, hFile, dwFlags );
|
|
if (!(dwFlags & (LOAD_LIBRARY_AS_DATAFILE |
|
|
LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE |
|
|
LOAD_LIBRARY_AS_IMAGE_RESOURCE)))
|
|
{
|
|
DEBUGSTR( 2, "LoadLibraryExW %S", lpFileName );
|
|
HookAPIAllMod( Hooks, FALSE, TRUE );
|
|
}
|
|
return hMod;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// IsConsoleHandle
|
|
// Determine if the handle is writing to the console, with processed output.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL IsConsoleHandle( HANDLE h )
|
|
{
|
|
int c;
|
|
|
|
for (c = 0; c < CACHE; ++c)
|
|
if (cache[c].h == h)
|
|
{
|
|
if (c != 0)
|
|
{
|
|
struct Cache tc = cache[c];
|
|
do cache[c] = cache[c-1]; while (--c > 0);
|
|
cache[0] = tc;
|
|
}
|
|
return (cache[0].mode & ENABLE_PROCESSED_OUTPUT);
|
|
}
|
|
|
|
while (--c > 0)
|
|
cache[c] = cache[c-1];
|
|
|
|
cache[0].h = h;
|
|
cache[0].mode = 0;
|
|
if (!GetConsoleMode( h, &cache[0].mode ))
|
|
{
|
|
// GetConsoleMode could fail if the console was not opened for reading
|
|
// (which is what Microsoft's conio output does). Verify the handle with
|
|
// WriteConsole (processed output is the default).
|
|
DWORD written;
|
|
if (WriteConsole( h, NULL, 0, &written, NULL ))
|
|
cache[0].mode = ENABLE_PROCESSED_OUTPUT;
|
|
}
|
|
|
|
return (cache[0].mode & ENABLE_PROCESSED_OUTPUT);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// MySetConsoleMode
|
|
// It seems GetConsoleMode is a relatively slow function, so call it once and
|
|
// keep track of changes directly.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
WINAPI MySetConsoleMode( HANDLE hCon, DWORD mode )
|
|
{
|
|
BOOL rc;
|
|
|
|
FlushBuffer();
|
|
|
|
rc = SetConsoleMode( hCon, mode );
|
|
if (rc)
|
|
{
|
|
int c;
|
|
for (c = 0; c < CACHE; ++c)
|
|
{
|
|
// The mode is associated with the buffer, not the handle.
|
|
GetConsoleMode( cache[c].h, &cache[c].mode );
|
|
}
|
|
if (hCon == hConOut)
|
|
awm = (mode & ENABLE_WRAP_AT_EOL_OUTPUT) ? TRUE : FALSE;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// MyWrite...
|
|
// The new functions that must replace the original Write... functions. These
|
|
// functions have exactly the same signature as the original ones. This
|
|
// module is not hooked, so we can still call the original functions ourselves.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static LPCSTR write_func;
|
|
|
|
BOOL
|
|
WINAPI MyWriteConsoleA( HANDLE hCon, LPCVOID lpBuffer,
|
|
DWORD nNumberOfCharsToWrite,
|
|
LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved )
|
|
{
|
|
LPWSTR buf;
|
|
WCHAR wBuf[1024];
|
|
DWORD len, wlen;
|
|
UINT cp;
|
|
BOOL rc = TRUE;
|
|
LPCSTR aBuf;
|
|
static char mb[4];
|
|
static DWORD mb_len, mb_size;
|
|
|
|
if (nNumberOfCharsToWrite != 0 && IsConsoleHandle( hCon ))
|
|
{
|
|
DEBUGSTR( 4, "%s: %u %\"<s",
|
|
(write_func == NULL) ? "WriteConsoleA" : write_func,
|
|
nNumberOfCharsToWrite, lpBuffer );
|
|
write_func = NULL;
|
|
aBuf = lpBuffer;
|
|
len = nNumberOfCharsToWrite;
|
|
wlen = 0;
|
|
cp = GetConsoleOutputCP();
|
|
// How to determine a multibyte character set? Cmd.Exe has IsDBCSCodePage,
|
|
// which tests code page numbers; ConHost has IsAvailableFarEastCodePage,
|
|
// which uses TranslateCharsetInfo; I used GetCPInfo in CMDRead. Let's use
|
|
// IsDBCSCodePage, as that avoids another API call.
|
|
if (cp == 932 || cp == 936 || cp == 949 || cp == 950)
|
|
{
|
|
if (mb_len == 1)
|
|
{
|
|
mb[1] = *aBuf++;
|
|
--len;
|
|
DEBUGSTR( 4, " %strail byte, removing & writing %\"*s",
|
|
(len == 0) ? "" : "starts with a ", 2, mb );
|
|
wlen = MultiByteToWideChar( cp, 0, mb, 2, wBuf, lenof(wBuf) );
|
|
ParseAndPrintString( hCon, wBuf, wlen, NULL );
|
|
mb_len = 0;
|
|
}
|
|
// A lead byte might also be a trail byte, so count all consecutive lead
|
|
// bytes - an even number means complete pairs, whilst an odd number
|
|
// means the last lead byte has been split.
|
|
if (len != 0 && IsDBCSLeadByteEx( cp, aBuf[len-1] ))
|
|
{
|
|
int lead = 1;
|
|
int pos = len - 1;
|
|
while (--pos >= 0 && IsDBCSLeadByteEx( cp, aBuf[pos] ))
|
|
++lead;
|
|
if (lead & 1)
|
|
{
|
|
mb[mb_len++] = aBuf[--len];
|
|
DEBUGSTR( 4, " %slead byte, removing",
|
|
(len == 0) ? "" : "ends with a " );
|
|
}
|
|
}
|
|
}
|
|
else if (cp == CP_UTF8)
|
|
{
|
|
if (mb_len != 0)
|
|
{
|
|
while ((*aBuf & 0xC0) == 0x80)
|
|
{
|
|
mb[mb_len++] = *aBuf++;
|
|
--len;
|
|
if (mb_len == mb_size)
|
|
break;
|
|
if (len == 0)
|
|
{
|
|
DEBUGSTR( 4, " trail byte%s, removing",
|
|
(nNumberOfCharsToWrite == 1) ? "" : "s" );
|
|
if (lpNumberOfCharsWritten != NULL)
|
|
*lpNumberOfCharsWritten = 0;
|
|
goto check_written;
|
|
}
|
|
}
|
|
if (log_level & 4)
|
|
{
|
|
DWORD tlen = nNumberOfCharsToWrite - len;
|
|
if (tlen == 0)
|
|
DEBUGSTR( 4, " incomplete UTF-8 sequence, writing %\"*s",
|
|
mb_len, mb );
|
|
else if (len == 0)
|
|
DEBUGSTR( 4, " trail byte%s, removing & writing %\"*s",
|
|
(tlen == 1) ? "" : "s", mb_len, mb );
|
|
else if (tlen == 1)
|
|
DEBUGSTR( 4, " starts with a trail byte, removing & writing %\"*s",
|
|
mb_len, mb );
|
|
else
|
|
DEBUGSTR( 4, " starts with %u trail bytes, removing & writing %\"*s",
|
|
tlen, mb_len, mb );
|
|
}
|
|
wlen = MultiByteToWideChar( cp, 0, mb, mb_len, wBuf, lenof(wBuf) );
|
|
ParseAndPrintString( hCon, wBuf, wlen, NULL );
|
|
mb_len = 0;
|
|
}
|
|
// In UTF-8, the high bit set means a lead or trail byte; if the next
|
|
// bit is clear, it's a trail byte; otherwise the number of set high bits
|
|
// counts the bytes in the sequence. The maximum legitimate sequence is
|
|
// four bytes.
|
|
if (len != 0 && (aBuf[len-1] & 0x80))
|
|
{
|
|
int pos = len;
|
|
while (--pos >= 0 && (aBuf[pos] & 0xC0) == 0x80)
|
|
;
|
|
if (pos >= 0 && (aBuf[pos] & 0x80) && len - pos < 4 &&
|
|
(pos == 0 || (aBuf[pos-1] & 0xC0) != 0xC0))
|
|
{
|
|
char lead = aBuf[pos];
|
|
mb_size = 0;
|
|
do
|
|
{
|
|
++mb_size;
|
|
lead <<= 1;
|
|
} while (lead & 0x80);
|
|
if (mb_size <= 4 && mb_size > len - pos)
|
|
{
|
|
mb_len = len - pos;
|
|
memcpy( mb, aBuf + pos, mb_len );
|
|
len = pos;
|
|
if (log_level & 4)
|
|
{
|
|
if (mb_len == nNumberOfCharsToWrite)
|
|
DEBUGSTR( 4, " lead byte%s, removing",
|
|
(mb_len == 1) ? "" : "s" );
|
|
else if (mb_len == 1)
|
|
DEBUGSTR( 4, " ends with a lead byte, removing" );
|
|
else
|
|
DEBUGSTR( 4, " ends with %u lead bytes, removing", mb_len );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (len == 0)
|
|
{
|
|
if (lpNumberOfCharsWritten != NULL)
|
|
*lpNumberOfCharsWritten = wlen;
|
|
goto check_written;
|
|
}
|
|
if (len <= lenof(wBuf))
|
|
buf = wBuf;
|
|
else
|
|
{
|
|
buf = HeapAlloc( hHeap, 0, TSIZE(len) );
|
|
if (buf == NULL)
|
|
{
|
|
DEBUGSTR( 4, "HeapAlloc failed, using original function" );
|
|
rc = WriteConsoleA( hCon, aBuf,len, lpNumberOfCharsWritten,lpReserved );
|
|
goto check_written;
|
|
}
|
|
}
|
|
len = MultiByteToWideChar( cp, 0, aBuf, len, buf, len );
|
|
rc = ParseAndPrintString( hCon, buf, len, lpNumberOfCharsWritten );
|
|
if (wlen != 0 && rc && lpNumberOfCharsWritten != NULL)
|
|
*lpNumberOfCharsWritten += wlen;
|
|
if (buf != wBuf)
|
|
HeapFree( hHeap, 0, buf );
|
|
check_written:
|
|
if (rc && lpNumberOfCharsWritten != NULL &&
|
|
*lpNumberOfCharsWritten != nNumberOfCharsToWrite)
|
|
{
|
|
// I set the number of characters actually written, which may be 0 when
|
|
// multibyte characters are split across calls. If that causes problems,
|
|
// restore original behaviour.
|
|
if (search_env( L"ANSICON_API", prog ))
|
|
*lpNumberOfCharsWritten = nNumberOfCharsToWrite;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
return WriteConsoleA( hCon, lpBuffer, nNumberOfCharsToWrite,
|
|
lpNumberOfCharsWritten, lpReserved );
|
|
}
|
|
|
|
BOOL
|
|
WINAPI MyWriteConsoleW( HANDLE hCon, LPCVOID lpBuffer,
|
|
DWORD nNumberOfCharsToWrite,
|
|
LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved )
|
|
{
|
|
if (nNumberOfCharsToWrite != 0 && IsConsoleHandle( hCon ))
|
|
{
|
|
DEBUGSTR( 4, "WriteConsoleW: %u %\"<S",
|
|
nNumberOfCharsToWrite, lpBuffer );
|
|
return ParseAndPrintString( hCon, lpBuffer,
|
|
nNumberOfCharsToWrite,
|
|
lpNumberOfCharsWritten );
|
|
}
|
|
|
|
return WriteConsoleW( hCon, lpBuffer, nNumberOfCharsToWrite,
|
|
lpNumberOfCharsWritten, lpReserved );
|
|
}
|
|
|
|
BOOL
|
|
WINAPI MyWriteFile( HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
|
|
LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped )
|
|
{
|
|
if (nNumberOfBytesToWrite != 0 && IsConsoleHandle( hFile ))
|
|
{
|
|
if (HandleToULong( hFile ) == STD_OUTPUT_HANDLE ||
|
|
HandleToULong( hFile ) == STD_ERROR_HANDLE)
|
|
hFile = GetStdHandle( HandleToULong( hFile ) );
|
|
|
|
write_func = "WriteFile";
|
|
MyWriteConsoleA( hFile, lpBuffer,nNumberOfBytesToWrite, NULL,lpOverlapped );
|
|
if (lpNumberOfBytesWritten != NULL)
|
|
*lpNumberOfBytesWritten = nNumberOfBytesToWrite;
|
|
return TRUE;
|
|
}
|
|
|
|
return WriteFile( hFile, lpBuffer, nNumberOfBytesToWrite,
|
|
lpNumberOfBytesWritten, lpOverlapped );
|
|
}
|
|
|
|
|
|
#define HHFILE (HANDLE)(DWORD_PTR)
|
|
|
|
UINT
|
|
WINAPI My_lwrite( HFILE hFile, LPCSTR lpBuffer, UINT uBytes )
|
|
{
|
|
if (uBytes != 0 && IsConsoleHandle( HHFILE hFile ))
|
|
{
|
|
write_func = "_lwrite";
|
|
MyWriteConsoleA( HHFILE hFile, lpBuffer, uBytes, NULL, NULL );
|
|
return uBytes;
|
|
}
|
|
|
|
return _lwrite( hFile, lpBuffer, uBytes );
|
|
}
|
|
|
|
|
|
VOID
|
|
WINAPI MyExitProcess( UINT uExitCode )
|
|
{
|
|
if (hBell != NULL)
|
|
WaitForSingleObject( hBell, INFINITE );
|
|
ExitProcess( uExitCode );
|
|
}
|
|
|
|
|
|
DWORD WINAPI FreeLibraryThread( LPVOID param )
|
|
{
|
|
FreeLibraryAndExitThread( hDllInstance, 0 );
|
|
return 0;
|
|
}
|
|
|
|
BOOL
|
|
WINAPI MyFreeLibrary( HMODULE hModule )
|
|
{
|
|
if (hModule == hDllInstance)
|
|
{
|
|
if (hBell != NULL)
|
|
WaitForSingleObject( hBell, INFINITE );
|
|
CloseHandle( CreateThread( NULL, 4096, FreeLibraryThread, NULL, 0, NULL ) );
|
|
return TRUE;
|
|
}
|
|
|
|
return FreeLibrary( hModule );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// MyCreate...
|
|
// Add GENERIC_READ access to enable retrieving console info.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
HANDLE
|
|
WINAPI MyCreateFileA( LPCSTR lpFileName, DWORD dwDesiredAccess,
|
|
DWORD dwShareMode,
|
|
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
|
|
DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes,
|
|
HANDLE hTemplateFile )
|
|
{
|
|
if (dwDesiredAccess == GENERIC_WRITE)
|
|
{
|
|
if (_stricmp( lpFileName, "con" ) == 0)
|
|
lpFileName = "CONOUT$";
|
|
if (_stricmp( lpFileName, "CONOUT$" ) == 0)
|
|
dwDesiredAccess |= GENERIC_READ;
|
|
}
|
|
return CreateFileA( lpFileName, dwDesiredAccess, dwShareMode,
|
|
lpSecurityAttributes, dwCreationDisposition,
|
|
dwFlagsAndAttributes, hTemplateFile );
|
|
}
|
|
|
|
HANDLE
|
|
WINAPI MyCreateFileW( LPCWSTR lpFileName, DWORD dwDesiredAccess,
|
|
DWORD dwShareMode,
|
|
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
|
|
DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes,
|
|
HANDLE hTemplateFile )
|
|
{
|
|
if (dwDesiredAccess == GENERIC_WRITE)
|
|
{
|
|
if (_wcsicmp( lpFileName, L"con" ) == 0)
|
|
lpFileName = L"CONOUT$";
|
|
if (_wcsicmp( lpFileName, L"CONOUT$" ) == 0)
|
|
dwDesiredAccess |= GENERIC_READ;
|
|
}
|
|
return CreateFileW( lpFileName, dwDesiredAccess, dwShareMode,
|
|
lpSecurityAttributes, dwCreationDisposition,
|
|
dwFlagsAndAttributes, hTemplateFile );
|
|
}
|
|
|
|
HANDLE
|
|
WINAPI MyCreateConsoleScreenBuffer( DWORD dwDesiredAccess, DWORD dwShareMode,
|
|
const SECURITY_ATTRIBUTES* lpSecurityAttributes,
|
|
DWORD dwFlags, LPVOID lpScreenBufferData )
|
|
{
|
|
dwDesiredAccess |= GENERIC_READ;
|
|
return CreateConsoleScreenBuffer( dwDesiredAccess, dwShareMode,
|
|
lpSecurityAttributes, dwFlags,
|
|
lpScreenBufferData );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// My...
|
|
// Flush the buffer before accessing the console.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define FLUSH2( func, arg2 ) \
|
|
BOOL WINAPI My##func( HANDLE a1, arg2 a2 )\
|
|
{ FlushBuffer(); return func( a1, a2 ); }
|
|
|
|
#define FLUSH2X( func, arg2 ) \
|
|
BOOL WINAPI My##func##Ex( HANDLE a1, arg2 a2 )\
|
|
{ FlushBuffer(); return func##X( a1, a2 ); }
|
|
|
|
#define FLUSH3( func, arg2, arg3 ) \
|
|
BOOL WINAPI My##func( HANDLE a1, arg2 a2, arg3 a3 )\
|
|
{ FlushBuffer(); return func( a1, a2, a3 ); }
|
|
|
|
#define FLUSH3X( func, arg2, arg3 ) \
|
|
BOOL WINAPI My##func##Ex( HANDLE a1, arg2 a2, arg3 a3 )\
|
|
{ FlushBuffer(); return func##X( a1, a2, a3 ); }
|
|
|
|
#define FLUSH4( func, arg2, arg3, arg4 ) \
|
|
BOOL WINAPI My##func( HANDLE a1, arg2 a2, arg3 a3, arg4 a4 )\
|
|
{ FlushBuffer(); return func( a1, a2, a3, a4 ); }
|
|
|
|
#define FLUSH5( func, arg2, arg3, arg4, arg5 ) \
|
|
BOOL WINAPI My##func( HANDLE a1, arg2 a2, arg3 a3, arg4 a4, arg5 a5 )\
|
|
{ FlushBuffer(); return func( a1, a2, a3, a4, a5 ); }
|
|
|
|
FLUSH5( FillConsoleOutputAttribute, WORD, DWORD, COORD, LPDWORD )
|
|
FLUSH5( FillConsoleOutputCharacterA, CHAR, DWORD, COORD, LPDWORD )
|
|
FLUSH5( FillConsoleOutputCharacterW, WCHAR, DWORD, COORD, LPDWORD )
|
|
FLUSH2( GetConsoleScreenBufferInfo, PCONSOLE_SCREEN_BUFFER_INFO )
|
|
FLUSH2X( GetConsoleScreenBufferInfo, PCONSOLE_SCREEN_BUFFER_INFOX )
|
|
FLUSH5( ReadFile, LPVOID, DWORD, LPDWORD, LPOVERLAPPED )
|
|
FLUSH5( ReadConsoleA, LPVOID, DWORD, LPDWORD, LPVOID )
|
|
FLUSH5( ReadConsoleW, LPVOID, DWORD, LPDWORD, LPVOID )
|
|
FLUSH4( ReadConsoleInputA, PINPUT_RECORD, DWORD, LPDWORD )
|
|
FLUSH4( ReadConsoleInputW, PINPUT_RECORD, DWORD, LPDWORD )
|
|
FLUSH5( ReadConsoleOutputA, PCHAR_INFO, COORD, COORD, PSMALL_RECT )
|
|
FLUSH5( ReadConsoleOutputW, PCHAR_INFO, COORD, COORD, PSMALL_RECT )
|
|
FLUSH5( ReadConsoleOutputAttribute, LPWORD, DWORD, COORD, LPDWORD )
|
|
FLUSH5( ReadConsoleOutputCharacterA, LPSTR, DWORD, COORD, LPDWORD )
|
|
FLUSH5( ReadConsoleOutputCharacterW, LPWSTR, DWORD, COORD, LPDWORD )
|
|
FLUSH5( ScrollConsoleScreenBufferA, SMALL_RECT*,SMALL_RECT*, COORD, CHAR_INFO* )
|
|
FLUSH5( ScrollConsoleScreenBufferW, SMALL_RECT*,SMALL_RECT*, COORD, CHAR_INFO* )
|
|
FLUSH2( SetConsoleCursorPosition, COORD )
|
|
FLUSH2( SetConsoleScreenBufferSize, COORD )
|
|
FLUSH2( SetConsoleTextAttribute, WORD )
|
|
FLUSH3( SetConsoleWindowInfo, BOOL, const SMALL_RECT* )
|
|
FLUSH3X( SetCurrentConsoleFont, BOOL, PCONSOLE_FONT_INFOX )
|
|
FLUSH5( WriteConsoleOutputA, const CHAR_INFO*, COORD, COORD, PSMALL_RECT )
|
|
FLUSH5( WriteConsoleOutputW, const CHAR_INFO*, COORD, COORD, PSMALL_RECT )
|
|
FLUSH5( WriteConsoleOutputAttribute, const WORD*, DWORD, COORD, LPDWORD )
|
|
FLUSH5( WriteConsoleOutputCharacterA, LPCSTR, DWORD, COORD, LPDWORD )
|
|
FLUSH5( WriteConsoleOutputCharacterW, LPCWSTR, DWORD, COORD, LPDWORD )
|
|
|
|
|
|
// ========== Environment variable
|
|
|
|
void set_ansicon( PCONSOLE_SCREEN_BUFFER_INFO pcsbi )
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO csbi;
|
|
TCHAR buf[64];
|
|
|
|
if (pcsbi == NULL)
|
|
{
|
|
HANDLE hConOut;
|
|
hConOut = CreateFile( L"CONOUT$", GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL, OPEN_EXISTING, 0, NULL );
|
|
GetConsoleScreenBufferInfo( hConOut, &csbi );
|
|
CloseHandle( hConOut );
|
|
pcsbi = &csbi;
|
|
}
|
|
|
|
wsprintf( buf, L"%dx%d (%dx%d)",
|
|
pcsbi->dwSize.X, pcsbi->dwSize.Y,
|
|
pcsbi->srWindow.Right - pcsbi->srWindow.Left + 1,
|
|
pcsbi->srWindow.Bottom - pcsbi->srWindow.Top + 1 );
|
|
SetEnvironmentVariable( L"ANSICON", buf );
|
|
}
|
|
|
|
DWORD
|
|
WINAPI MyGetEnvironmentVariableA( LPCSTR lpName, LPSTR lpBuffer, DWORD nSize )
|
|
{
|
|
if (_stricmp( lpName, "ANSICON_VER" ) == 0)
|
|
{
|
|
if (nSize < sizeof(PVEREA))
|
|
return sizeof(PVEREA);
|
|
memcpy( lpBuffer, PVEREA, sizeof(PVEREA) );
|
|
return sizeof(PVEREA) - 1;
|
|
}
|
|
|
|
if (_stricmp( lpName, "CLICOLOR" ) == 0)
|
|
{
|
|
if (nSize < 2)
|
|
return 2;
|
|
lpBuffer[0] = '1';
|
|
lpBuffer[1] = '\0';
|
|
return 1;
|
|
}
|
|
|
|
if (_stricmp( lpName, "ANSICON" ) == 0)
|
|
set_ansicon( NULL );
|
|
|
|
return GetEnvironmentVariableA( lpName, lpBuffer, nSize );
|
|
}
|
|
|
|
DWORD
|
|
WINAPI MyGetEnvironmentVariableW( LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize )
|
|
{
|
|
if (_wcsicmp( lpName, L"ANSICON_VER" ) == 0)
|
|
{
|
|
if (nSize < lenof(PVERE))
|
|
return lenof(PVERE);
|
|
memcpy( lpBuffer, PVERE, sizeof(PVERE) );
|
|
return lenof(PVERE) - 1;
|
|
}
|
|
|
|
if (_wcsicmp( lpName, L"CLICOLOR" ) == 0)
|
|
{
|
|
if (nSize < 2)
|
|
return 2;
|
|
lpBuffer[0] = '1';
|
|
lpBuffer[1] = '\0';
|
|
return 1;
|
|
}
|
|
|
|
if (_wcsicmp( lpName, L"ANSICON" ) == 0)
|
|
set_ansicon( NULL );
|
|
|
|
return GetEnvironmentVariableW( lpName, lpBuffer, nSize );
|
|
}
|
|
|
|
|
|
// ========== Initialisation
|
|
|
|
#define HOOK( dll, name ) { dll, #name, (PROC)My##name, NULL, NULL, NULL }
|
|
|
|
HookFn Hooks[] = {
|
|
// These two are expected first!
|
|
HOOK( APILibraryLoader, LoadLibraryA ),
|
|
HOOK( APILibraryLoader, LoadLibraryW ),
|
|
HOOK( APIProcessThreads, CreateProcessA ),
|
|
HOOK( APIProcessThreads, CreateProcessW ),
|
|
HOOK( APIProcessEnvironment, GetEnvironmentVariableA ),
|
|
HOOK( APIProcessEnvironment, GetEnvironmentVariableW ),
|
|
HOOK( APILibraryLoader, GetProcAddress ),
|
|
HOOK( APILibraryLoader, LoadLibraryExA ),
|
|
HOOK( APILibraryLoader, LoadLibraryExW ),
|
|
HOOK( APIConsole, SetConsoleMode ),
|
|
HOOK( APIConsole, WriteConsoleA ),
|
|
HOOK( APIConsole, WriteConsoleW ),
|
|
HOOK( APIFile, WriteFile ),
|
|
HOOK( APIKernel, _lwrite ),
|
|
HOOK( APIProcessThreads, ExitProcess ),
|
|
HOOK( APILibraryLoader, FreeLibrary ),
|
|
HOOK( APIFile, CreateFileA ),
|
|
HOOK( APIFile, CreateFileW ),
|
|
HOOK( APIKernel, CreateConsoleScreenBuffer ),
|
|
HOOK( APIKernel, FillConsoleOutputAttribute ),
|
|
HOOK( APIKernel, FillConsoleOutputCharacterA ),
|
|
HOOK( APIKernel, FillConsoleOutputCharacterW ),
|
|
HOOK( APIKernel, GetConsoleScreenBufferInfo ),
|
|
HOOK( APIKernel, GetConsoleScreenBufferInfoEx ),
|
|
HOOK( APIFile, ReadFile ),
|
|
HOOK( APIConsole, ReadConsoleA ),
|
|
HOOK( APIConsole, ReadConsoleW ),
|
|
HOOK( APIConsole, ReadConsoleInputA ),
|
|
HOOK( APIConsole, ReadConsoleInputW ),
|
|
HOOK( APIKernel, ReadConsoleOutputA ),
|
|
HOOK( APIKernel, ReadConsoleOutputW ),
|
|
HOOK( APIKernel, ReadConsoleOutputAttribute ),
|
|
HOOK( APIKernel, ReadConsoleOutputCharacterA ),
|
|
HOOK( APIKernel, ReadConsoleOutputCharacterW ),
|
|
HOOK( APIKernel, ScrollConsoleScreenBufferA ),
|
|
HOOK( APIKernel, ScrollConsoleScreenBufferW ),
|
|
HOOK( APIKernel, SetConsoleCursorPosition ),
|
|
HOOK( APIKernel, SetConsoleScreenBufferSize ),
|
|
HOOK( APIKernel, SetConsoleTextAttribute ),
|
|
HOOK( APIKernel, SetConsoleWindowInfo ),
|
|
HOOK( APIKernel, WriteConsoleOutputA ),
|
|
HOOK( APIKernel, WriteConsoleOutputW ),
|
|
HOOK( APIKernel, WriteConsoleOutputAttribute ),
|
|
HOOK( APIKernel, WriteConsoleOutputCharacterA ),
|
|
HOOK( APIKernel, WriteConsoleOutputCharacterW ),
|
|
{ NULL, NULL, NULL, NULL, NULL, NULL }
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// OriginalAttr()
|
|
// Determine the original attributes for use by \e[m.
|
|
//-----------------------------------------------------------------------------
|
|
void OriginalAttr( PVOID lpReserved )
|
|
{
|
|
HANDLE hConOut;
|
|
CONSOLE_SCREEN_BUFFER_INFO Info;
|
|
|
|
hConOut = CreateFile( L"CONOUT$", GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL, OPEN_EXISTING, 0, NULL );
|
|
if (!GetConsoleScreenBufferInfo( hConOut, &Info ))
|
|
ATTR = 7;
|
|
|
|
// If we were loaded dynamically, remember the current attributes to restore
|
|
// upon unloading. However, if we're the 64-bit DLL, but the image is 32-
|
|
// bit, then the dynamic load was due to injecting into AnyCPU.
|
|
if (lpReserved == NULL)
|
|
{
|
|
#ifdef _WIN64
|
|
PIMAGE_DOS_HEADER pDosHeader;
|
|
PIMAGE_NT_HEADERS pNTHeader;
|
|
pDosHeader = (PIMAGE_DOS_HEADER)GetModuleHandle( NULL );
|
|
pNTHeader = MakeVA( PIMAGE_NT_HEADERS, pDosHeader->e_lfanew );
|
|
if (pNTHeader->FileHeader.Machine == IMAGE_FILE_MACHINE_AMD64)
|
|
#endif
|
|
orgattr = ATTR;
|
|
GetConsoleMode( hConOut, &orgmode );
|
|
GetConsoleCursorInfo( hConOut, &orgcci );
|
|
}
|
|
CloseHandle( hConOut );
|
|
|
|
get_state();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// DllMain()
|
|
// Function called by the system when processes and threads are initialized
|
|
// and terminated.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Need to export something for static loading to work, this is as good as any.
|
|
__declspec(dllexport)
|
|
BOOL WINAPI DllMain( HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved )
|
|
{
|
|
BOOL bResult = TRUE;
|
|
PHookFn hook;
|
|
TCHAR logstr[4];
|
|
typedef LONG (WINAPI *PNTQIT)( HANDLE, int, PVOID, ULONG, PULONG );
|
|
static PNTQIT NtQueryInformationThread;
|
|
|
|
if (dwReason == DLL_PROCESS_ATTACH)
|
|
{
|
|
hHeap = HeapCreate( 0, 0, 128 * 1024 );
|
|
hKernel = GetModuleHandleA( APIKernel );
|
|
GetConsoleScreenBufferInfoX = (PHCSBIX)GetProcAddress(
|
|
hKernel, "GetConsoleScreenBufferInfoEx" );
|
|
SetConsoleScreenBufferInfoX = (PHCSBIX)GetProcAddress(
|
|
hKernel, "SetConsoleScreenBufferInfoEx" );
|
|
SetCurrentConsoleFontX = (PHBCFIX)GetProcAddress(
|
|
hKernel, "SetCurrentConsoleFontEx" );
|
|
|
|
*logstr = '\0';
|
|
GetEnvironmentVariable( L"ANSICON_LOG", logstr, lenof(logstr) );
|
|
log_level = _wtoi( logstr );
|
|
prog = get_program_name( NULL );
|
|
#if defined(_WIN64) || defined(W32ON64)
|
|
DllNameType = DllName - 6 +
|
|
#endif
|
|
GetModuleFileName( hInstance, DllName, lenof(DllName) );
|
|
set_ansi_dll();
|
|
|
|
hDllInstance = hInstance; // save Dll instance handle
|
|
DEBUGSTR( 1, "hDllInstance = %p", hDllInstance );
|
|
|
|
// Get the entry points to the original functions.
|
|
for (hook = Hooks; hook->name; ++hook)
|
|
hook->oldfunc = GetProcAddress( hKernel, hook->name );
|
|
|
|
// Get my import addresses, to detect if anyone's hooked me.
|
|
DEBUGSTR( 2, "Storing my imports" );
|
|
HookAPIOneMod( NULL, Hooks, FALSE, "" );
|
|
|
|
bResult = HookAPIAllMod( Hooks, FALSE, FALSE );
|
|
OriginalAttr( lpReserved );
|
|
|
|
NtQueryInformationThread = (PNTQIT)GetProcAddress(
|
|
GetModuleHandle( L"ntdll.dll" ), "NtQueryInformationThread" );
|
|
if (NtQueryInformationThread == NULL)
|
|
DisableThreadLibraryCalls( hInstance );
|
|
|
|
InitializeCriticalSection( &CritSect );
|
|
hFlushTimer = CreateWaitableTimer( NULL, FALSE, NULL );
|
|
CreateThread( NULL, 4096, FlushThread, NULL, 0, NULL );
|
|
}
|
|
else if (dwReason == DLL_PROCESS_DETACH)
|
|
{
|
|
FlushBuffer();
|
|
if (lpReserved == NULL)
|
|
{
|
|
DEBUGSTR( 1, "Unloading" );
|
|
HookAPIAllMod( Hooks, TRUE, FALSE );
|
|
}
|
|
else
|
|
{
|
|
DEBUGSTR( 1, "Terminating" );
|
|
}
|
|
if (orgattr != 0)
|
|
{
|
|
hConOut = CreateFile( L"CONOUT$", GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL, OPEN_EXISTING, 0, NULL );
|
|
SetConsoleTextAttribute( hConOut, orgattr );
|
|
SetConsoleMode( hConOut, orgmode );
|
|
SetConsoleCursorInfo( hConOut, &orgcci );
|
|
CloseHandle( hConOut );
|
|
}
|
|
if (hMap != NULL)
|
|
{
|
|
UnmapViewOfFile( pState );
|
|
CloseHandle( hMap );
|
|
}
|
|
HeapDestroy( hHeap );
|
|
}
|
|
else if (dwReason == DLL_THREAD_DETACH)
|
|
{
|
|
PVOID start;
|
|
if (NtQueryInformationThread( GetCurrentThread(),
|
|
9 /* ThreadQuerySetWin32StartAddress */,
|
|
&start, sizeof(start), NULL ) == 0
|
|
&& (start == Hooks[0].oldfunc || start == Hooks[1].oldfunc
|
|
|| start == Hooks[0].apifunc || start == Hooks[1].apifunc))
|
|
{
|
|
DEBUGSTR( 2, "Injection detected" );
|
|
HookAPIAllMod( Hooks, FALSE, TRUE );
|
|
}
|
|
}
|
|
return bResult;
|
|
}
|