/**
* Check if the stream is for a Window console.
*
* @returns true / false.
* @param pStream The stream.
* @param phCon Where to return the console handle.
*/
static bool rtStrmIsConsoleUnlocked(PRTSTREAM pStream, HANDLE *phCon)
{
int fh = fileno(pStream->pFile);
if (isatty(fh))
{
DWORD dwMode;
HANDLE hCon = (HANDLE)_get_osfhandle(fh);
if (GetConsoleMode(hCon, &dwMode))
{
*phCon = hCon;
return true;
}
}
return false;
}
CAMLprim value win_get_console_mode (value unit)
{
DWORD mode;
BOOL res;
init_conin ();
res = GetConsoleMode (conin, &mode);
if (res == 0) {
win32_maperr (GetLastError ());
uerror("get_console_mode", Nothing);
}
return (Val_int (mode));
}
void TThreads::resume() {
if (!inited) {
SetFileApisToOEM();
chandle[cnInput] = GetStdHandle(STD_INPUT_HANDLE);
chandle[cnOutput] = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleCursorInfo(chandle[cnOutput], &crInfo);
GetConsoleScreenBufferInfo(chandle[cnOutput], &sbInfo);
GetConsoleMode(chandle[cnInput],&consoleMode);
consoleMode &= ~(ENABLE_LINE_INPUT|ENABLE_ECHO_INPUT|ENABLE_WINDOW_INPUT);
SetConsoleMode(chandle[cnInput],consoleMode);
evpending = 0;
inited = 1;
}
}
BOOL WINAPI OnPeekConsoleInputA(HANDLE hConsoleInput, PINPUT_RECORD lpBuffer, DWORD nLength, LPDWORD lpNumberOfEventsRead)
{
//typedef BOOL (WINAPI* OnPeekConsoleInputA_t)(HANDLE,PINPUT_RECORD,DWORD,LPDWORD);
SUPPRESSORIGINALSHOWCALL;
ORIGINAL_KRNL(PeekConsoleInputA);
//if (gpFarInfo && bMainThread)
// TouchReadPeekConsoleInputs(1);
BOOL lbRc = FALSE;
if (ph && ph->PreCallBack)
{
SETARGS4(&lbRc,hConsoleInput,lpBuffer,nLength,lpNumberOfEventsRead);
// Если функция возвращает FALSE - реальное чтение не будет вызвано
if (!ph->PreCallBack(&args))
return lbRc;
}
PreReadConsoleInput(hConsoleInput, rcif_Ansi|rcif_Peek|rcif_LLInput);
//#ifdef USE_INPUT_SEMAPHORE
//DWORD nSemaphore = ghConInSemaphore ? WaitForSingleObject(ghConInSemaphore, INSEMTIMEOUT_READ) : 1;
//_ASSERTE(nSemaphore<=1);
//#endif
#if 0
DWORD nMode = 0; GetConsoleMode(hConsoleInput, &nMode);
#endif
lbRc = F(PeekConsoleInputA)(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead);
PostReadConsoleInput(hConsoleInput, rcif_Ansi|rcif_Peek|rcif_LLInput);
//#ifdef USE_INPUT_SEMAPHORE
//if ((nSemaphore == WAIT_OBJECT_0) && ghConInSemaphore) ReleaseSemaphore(ghConInSemaphore, 1, NULL);
//#endif
if (ph && ph->PostCallBack)
{
SETARGS4(&lbRc,hConsoleInput,lpBuffer,nLength,lpNumberOfEventsRead);
ph->PostCallBack(&args);
}
if (lbRc && lpNumberOfEventsRead && *lpNumberOfEventsRead && lpBuffer)
OnPeekReadConsoleInput('P', 'A', hConsoleInput, lpBuffer, *lpNumberOfEventsRead);
return lbRc;
}
/*
==================
CON_Init
==================
*/
void CON_Init( void )
{
CONSOLE_CURSOR_INFO curs;
CONSOLE_SCREEN_BUFFER_INFO info;
int i;
// handle Ctrl-C or other console termination
SetConsoleCtrlHandler( CON_CtrlHandler, TRUE );
qconsole_hin = GetStdHandle( STD_INPUT_HANDLE );
if ( qconsole_hin == INVALID_HANDLE_VALUE )
{
return;
}
qconsole_hout = GetStdHandle( STD_OUTPUT_HANDLE );
if ( qconsole_hout == INVALID_HANDLE_VALUE )
{
return;
}
GetConsoleMode( qconsole_hin, &qconsole_orig_mode );
// allow mouse wheel scrolling
SetConsoleMode( qconsole_hin,
qconsole_orig_mode & ~ENABLE_MOUSE_INPUT );
FlushConsoleInputBuffer( qconsole_hin );
GetConsoleScreenBufferInfo( qconsole_hout, &info );
qconsole_attrib = info.wAttributes;
SetConsoleTitle( "Daemon Console" );
// make cursor invisible
GetConsoleCursorInfo( qconsole_hout, &qconsole_orig_cursorinfo );
curs.dwSize = 1;
curs.bVisible = FALSE;
SetConsoleCursorInfo( qconsole_hout, &curs );
// initialize history
for ( i = 0; i < QCONSOLE_HISTORY; i++ )
{
qconsole_history[ i ][ 0 ] = '\0';
}
}
static void
disable_quick_edit(void)
{
DWORD mode = 0;
HANDLE console = GetStdHandle(STD_INPUT_HANDLE);
// Get current console mode
if (console == NULL || !GetConsoleMode(console, &mode)) {
return;
}
// Clear the quick edit bit in the mode flags
mode &= ~ENABLE_QUICK_EDIT;
mode |= ENABLE_EXTENDED_FLAGS;
SetConsoleMode(console, mode);
}
ConsoleMedia::ConsoleMedia()
{
m_bRedirectedToFile = true;
m_hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
if (m_hConsole == NULL)
{
if (!AllocConsole() //|| !SetConsoleTitle(_T("Log"))
|| (m_hConsole = GetStdHandle(STD_OUTPUT_HANDLE)) == NULL)
return;
}
GetConsoleScreenBufferInfo(m_hConsole, &m_info);
DWORD t;
m_bRedirectedToFile = GetConsoleMode(m_hConsole, &t) == FALSE;
}
void alloc_console() {
CONSOLE_SCREEN_BUFFER_INFO coninfo;
HANDLE hStdin = GetStdHandle (STD_INPUT_HANDLE);
DWORD lpMode;
AllocConsole ();
GetConsoleMode (hStdin, &lpMode);
SetConsoleMode (hStdin, lpMode & (~ENABLE_MOUSE_INPUT | ENABLE_PROCESSED_INPUT));
GetConsoleScreenBufferInfo (hStdin, &coninfo);
coninfo.dwSize.Y = 4096;
SetConsoleScreenBufferSize (hStdin, coninfo.dwSize);
freopen ("conin$", "r", stdin);
freopen ("conout$", "w", stdout);
freopen ("conout$", "w", stderr);
}
void console_widget_NT_t::init_new_console()
{
allocated_console = false;
saved_hwnd = GetConsoleWindow();
if (saved_hwnd == (HWND)0) {
AllocConsole();
allocated_console = true;
saved_hwnd = GetConsoleWindow();
}
saved_input = GetStdHandle(STD_INPUT_HANDLE);
saved_output = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleCursorInfo(saved_output, &saved_cursor);
GetConsoleMode(saved_input, &saved_mode);
}
int rktio_system_fd_is_terminal(rktio_t *rktio, intptr_t fd)
{
#ifdef RKTIO_SYSTEM_UNIX
return isatty(fd);
#endif
#ifdef RKTIO_SYSTEM_WINDOWS
if (GetFileType((HANDLE)fd) == FILE_TYPE_CHAR) {
DWORD mode;
if (GetConsoleMode((HANDLE)fd, &mode))
return 1;
else
return 0;
} else
return 0;
#endif
}
int
SLMprintf(
WCHAR *szformat, ...)
{
va_list marker;
int iret = 0;
int count;
long cbWritten;
DWORD dwMode;
va_start(marker, szformat);
count = vswprintf(szText, szformat, marker);
if (!bUnicode) {
memset (chBuf, 0, sizeof(chBuf));
#ifdef _WIN32
WideCharToMultiByte (CP_ACP, 0, szText, count, chBuf, sizeof(chBuf), NULL, NULL);
#else
wcstombs (chBuf, szText, sizeof(chBuf));
#endif
iret = printf("%s", chBuf);
if (fCkSum)
CheckSum(chBuf, strlen(chBuf));
}
else {
#ifdef _WIN32
if (GetConsoleMode((HANDLE)_get_osfhandle(_fileno(stdout)), &dwMode)) {
WriteConsoleW ((HANDLE)_get_osfhandle(_fileno(stdout)),
szText,
count,
&cbWritten,
NULL);
iret = cbWritten;
}
else
iret = wprintf(szText);
#else
iret = wprintf(szText);
#endif
if (fCkSum)
CheckSum((char *)szText, wcslen(szText) * sizeof(WCHAR));
}
va_end(marker);
return (iret);
}
int csync_getpass(const char *prompt,
char *buf,
size_t len,
int echo,
int verify,
void *userdata
) {
/* unused variables */
(void) userdata;
HANDLE h;
DWORD mode = 0;
int ok;
/* fgets needs at least len - 1 */
if (prompt == NULL || buf == NULL || len < 2) {
return -1;
}
/* get stdin and mode */
h = GetStdHandle(STD_INPUT_HANDLE);
if (!GetConsoleMode(h, &mode)) {
return -1;
}
/* disable echo */
if (!echo) {
if (!SetConsoleMode(h, mode & ~ENABLE_ECHO_INPUT)) {
return -1;
}
}
ok = csync_gets(prompt, buf, len, verify);
/* reset echo */
SetConsoleMode(h, mode);
if (!ok) {
memset (buf, '\0', len);
return -1;
}
/* force termination */
buf[len - 1] = '\0';
return 0;
}
/* ************************************
* VOID ChangeMode( HANDLE hStdin, HANDLE hStdout)
* 功能 改变控制台的模式，关闭ENABLE_LINE_INPUT和ENABLE_ECHO_INPUT
* 参数 HANDLE hStdin, HANDLE hStdout，句柄
**************************************/
VOID ChangeMode( HANDLE hStdin, HANDLE hStdout)
{
LPSTR lpszPrompt = "Mode changeed Type any key, or q to quit: ";
CHAR chBuffer[256];
DWORD fdwMode, fdwOldMode;
DWORD cRead,cWritten;
// 获取当前模式
if (! GetConsoleMode(hStdin, &fdwOldMode))
{
MessageBox(NULL, "GetConsoleMode", "Console Error", MB_OK);
return;
}
// 修改模式并重新设置
fdwMode = fdwOldMode &
~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT);
if (! SetConsoleMode(hStdin, fdwMode))
{
MessageBox(NULL, "SetConsoleMode", "Console Error", MB_OK);
return;
}
// 换行
NewLine();
// 循环等待输入并处理
while (1)
{
if (! WriteFile( hStdout,
lpszPrompt, lstrlen(lpszPrompt),
&cWritten, NULL) )
{
MyErrorExit("WriteFile");
return;
}
if (! ReadFile(hStdin, chBuffer, 1, &cRead, NULL))
break;
if (chBuffer[0] == '\r')
NewLine();
else if (! WriteFile(hStdout, chBuffer, cRead,
&cWritten, NULL)) break;
else
NewLine();
if (chBuffer[0] == 'q') break; // 输入q，退出
}
// 恢复模式
SetConsoleMode(hStdin, fdwOldMode);
}
R_API RCons *r_cons_new () {
I.line = r_line_new ();
I.event_interrupt = NULL;
I.blankline = R_TRUE;
I.heightfix = 0;
I.widthfix = 0;
I.event_resize = NULL;
I.data = NULL;
I.event_data = NULL;
I.is_interactive = R_TRUE;
I.noflush = R_FALSE;
I.force_rows = 0;
I.force_columns = 0;
I.fdin = stdin;
I.fdout = 1;
I.breaked = R_FALSE;
//I.lines = 0;
I.buffer = NULL;
I.buffer_sz = 0;
I.buffer_len = 0;
r_cons_get_size (NULL);
I.num = NULL;
#if EMSCRIPTEN
/* do nothing here :? */
#elif __UNIX__
tcgetattr (0, &I.term_buf);
memcpy (&I.term_raw, &I.term_buf, sizeof (I.term_raw));
I.term_raw.c_iflag &= ~(BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
I.term_raw.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
I.term_raw.c_cflag &= ~(CSIZE|PARENB);
I.term_raw.c_cflag |= CS8;
I.term_raw.c_cc[VMIN] = 1; // Solaris stuff hehe
signal (SIGWINCH, resize);
#elif __WINDOWS__
h = GetStdHandle (STD_INPUT_HANDLE);
GetConsoleMode (h, (PDWORD) &I.term_buf);
I.term_raw = 0;
if (!SetConsoleCtrlHandler ((PHANDLER_ROUTINE)__w32_control, TRUE))
eprintf ("r_cons: Cannot set control console handler\n");
#endif
I.pager = NULL; /* no pager by default */
I.truecolor = 0;
r_cons_pal_init (NULL);
r_cons_rgb_init ();
r_cons_reset ();
return &I;
}
/* MS runtime's isatty returns non-zero for any character device,
including the null device, which is not what we want. */
int
isatty (int fd)
{
HANDLE fh = (HANDLE) _get_osfhandle (fd);
DWORD con_mode;
if (fh == INVALID_HANDLE_VALUE)
{
errno = EBADF;
return 0;
}
if (GetConsoleMode (fh, &con_mode))
return 1;
errno = ENOTTY;
return 0;
}
JNIEXPORT jint JNICALL Java_jline_WindowsTerminal_getConsoleMode
(JNIEnv *env, jobject ob)
{
DWORD mode;
HANDLE hConsole = GetStdHandle (STD_INPUT_HANDLE);
if (hConsole == INVALID_HANDLE_VALUE)
return -1;
if (!GetConsoleMode (hConsole, &mode))
return -1;
// CloseHandle (hConsole);
// printf ("JNI get mode=%d\n", mode);
return mode;
}
char *
getpass (const char * prompt)
{
static char input[256];
HANDLE in;
HANDLE err;
DWORD count;
in = GetStdHandle (STD_INPUT_HANDLE);
err = GetStdHandle (STD_ERROR_HANDLE);
if (in == INVALID_HANDLE_VALUE || err == INVALID_HANDLE_VALUE)
return NULL;
if (WriteFile (err, prompt, strlen (prompt), &count, NULL))
{
int istty = (GetFileType (in) == FILE_TYPE_CHAR);
DWORD old_flags;
int rc;
if (istty)
{
if (GetConsoleMode (in, &old_flags))
SetConsoleMode (in, ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT);
else
istty = 0;
}
rc = ReadFile (in, input, sizeof (input), &count, NULL);
if (count >= 2 && input[count - 2] == '\r')
input[count - 2] = '\0';
else
{
char buf[256];
while (ReadFile (in, buf, sizeof (buf), &count, NULL) > 0)
if (count >= 2 && buf[count - 2] == '\r')
break;
}
WriteFile (err, "\r\n", 2, &count, NULL);
if (istty)
SetConsoleMode (in, old_flags);
if (rc)
return input;
}
return NULL;
}
bool CConsole::Create(const char *szTitle, bool bNoClose)
{
unsigned long ulMode;
// Has console been already created?
if(hConsole != NULL)
return false;
// Allocate a new console for our app
if(!AllocConsole())
return false;
hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
// Create the actual console
// hConsole = CreateFile("CONOUT$", GENERIC_WRITE|GENERIC_READ, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
if(hConsole == INVALID_HANDLE_VALUE)
return false;
ulMode = (ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT );
if(SetConsoleMode(hConsole, ulMode ) == 0)
return false;
// if true, disable the [x] button of the console
if(bNoClose)
DisableClose();
// set the console title
if(szTitle != NULL)
SetConsoleTitle(szTitle);
// Disable QuickEdit mode - it's dangerous:
// just a click on the console window can stop the application
#define ENABLE_QUICK_EDIT_MODE 0x0040
#define ENABLE_EXTENDED_FLAGS 0x0080
HANDLE hStdIn;
hStdIn = GetStdHandle(STD_INPUT_HANDLE);
GetConsoleMode(hStdIn, &ulMode );
ulMode |= ENABLE_EXTENDED_FLAGS;
ulMode &= ~ENABLE_QUICK_EDIT_MODE;
if(SetConsoleMode(hStdIn, ulMode ) == 0)
return false;
return true;
}
int
SLMprintfLn(
WCHAR *szLine)
{
long cbWritten;
WORD count;
BYTE *lpBuf;
DWORD dwMode;
count = wcslen(szLine);
if (!bUnicode) {
lpBuf = pvAllocMem (count + 50);
memset (lpBuf, 0, count + 50);
#ifdef _WIN32
WideCharToMultiByte (CP_ACP, 0, szLine, count, lpBuf, count + 50, NULL, NULL);
#else
wcstombs (lpBuf, szLine, count + 50);
#endif
count = printf("%s", lpBuf);
if (fCkSum)
CheckSum(lpBuf, strlen(lpBuf));
FreeMem (lpBuf);
return (count);
}
else {
if (fCkSum)
CheckSum((char *)szLine, count * sizeof(WCHAR));
#ifdef _WIN32
if (GetConsoleMode((HANDLE)_get_osfhandle(_fileno(stdout)), &dwMode))
return (WriteConsoleW ((HANDLE)_get_osfhandle(_fileno(stdout)),
szLine,
wcslen(szLine),
&cbWritten,
NULL));
else
return (wprintf(L"%s", szLine));
#else
return (wprintf(L"%s", szLine));
#endif
}
}
JNIEXPORT jint JNICALL Java_org_trafodion_ci_WCIUtils_getConsoleMode
(JNIEnv *env, jobject ob)
{
DWORD mode;
HANDLE hConsole = GetStdHandle (STD_INPUT_HANDLE);
if (hConsole == INVALID_HANDLE_VALUE)
return -1;
if (!GetConsoleMode (hConsole, &mode))
return -1;
// CloseHandle (hConsole);
//printf ("JNI get mode=%d\n", mode);
return mode;
}
static int enableRawMode(int fd) {
#ifdef _WIN32
if (!console_in) {
console_in = GetStdHandle(STD_INPUT_HANDLE);
console_out = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleMode(console_in, &oldMode);
SetConsoleMode(console_in, oldMode & ~(ENABLE_LINE_INPUT | ENABLE_LINE_INPUT));
}
return 0;
#else
struct termios raw;
if (!isatty(STDIN_FILENO)) goto fatal;
if (!atexit_registered) {
atexit(linenoiseAtExit);
atexit_registered = 1;
}
if (tcgetattr(fd,&orig_termios) == -1) goto fatal;
raw = orig_termios; /* modify the original mode */
/* input modes: no break, no CR to NL, no parity check, no strip char,
* no start/stop output control. */
raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
/* output modes - disable post processing */
raw.c_oflag &= ~(OPOST);
/* control modes - set 8 bit chars */
raw.c_cflag |= (CS8);
/* local modes - choing off, canonical off, no extended functions,
* no signal chars (^Z,^C) */
raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
/* control chars - set return condition: min number of bytes and timer.
* We want read to return every single byte, without timeout. */
raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; /* 1 byte, no timer */
/* put terminal in raw mode after flushing */
if (tcsetattr(fd,TCSAFLUSH,&raw) < 0) goto fatal;
rawmode = 1;
return 0;
fatal:
errno = ENOTTY;
return -1;
#endif
}
/*
* Ask whether to wipe a session log file before writing to it.
* Returns 2 for wipe, 1 for append, 0 for cancel (don't log).
*/
int askappend(char *filename)
{
HANDLE hin;
DWORD savemode, i;
static const char msgtemplate[] =
"The session log file \"%.*s\" already exists.\n"
"You can overwrite it with a new session log,\n"
"append your session log to the end of it,\n"
"or disable session logging for this session.\n"
"Enter \"y\" to wipe the file, \"n\" to append to it,\n"
"or just press Return to disable logging.\n"
"Wipe the log file? (y/n, Return cancels logging) ";
static const char msgtemplate_batch[] =
"The session log file \"%.*s\" already exists.\n"
"Logging will not be enabled.\n";
char line[32];
if (cfg.logxfovr != LGXF_ASK) {
return ((cfg.logxfovr == LGXF_OVR) ? 2 : 1);
}
if (console_batch_mode) {
fprintf(stderr, msgtemplate_batch, FILENAME_MAX, filename);
fflush(stderr);
return 0;
}
fprintf(stderr, msgtemplate, FILENAME_MAX, filename);
fflush(stderr);
hin = GetStdHandle(STD_INPUT_HANDLE);
GetConsoleMode(hin, &savemode);
SetConsoleMode(hin, (savemode | ENABLE_ECHO_INPUT |
ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT));
ReadFile(hin, line, sizeof(line) - 1, &i, NULL);
SetConsoleMode(hin, savemode);
if (line[0] == 'y' || line[0] == 'Y')
return 2;
else if (line[0] == 'n' || line[0] == 'N')
return 1;
else
return 0;
}
/*
* Ask whether the selected cipher is acceptable (since it was
* below the configured 'warn' threshold).
* cs: 0 = both ways, 1 = client->server, 2 = server->client
*/
void askcipher(char *ciphername, int cs)
{
HANDLE hin;
DWORD savemode, i;
static const char msg[] =
"The first %scipher supported by the server is\n"
"%s, which is below the configured warning threshold.\n"
"Continue with connection? (y/n) ";
static const char msg_batch[] =
"The first %scipher supported by the server is\n"
"%s, which is below the configured warning threshold.\n"
"Connection abandoned.\n";
static const char abandoned[] = "Connection abandoned.\n";
char line[32];
if (console_batch_mode) {
fprintf(stderr, msg_batch,
(cs == 0) ? "" :
(cs == 1) ? "client-to-server " : "server-to-client ",
ciphername);
cleanup_exit(1);
}
fprintf(stderr, msg,
(cs == 0) ? "" :
(cs == 1) ? "client-to-server " : "server-to-client ",
ciphername);
fflush(stderr);
hin = GetStdHandle(STD_INPUT_HANDLE);
GetConsoleMode(hin, &savemode);
SetConsoleMode(hin, (savemode | ENABLE_ECHO_INPUT |
ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT));
ReadFile(hin, line, sizeof(line) - 1, &i, NULL);
SetConsoleMode(hin, savemode);
if (line[0] == 'y' || line[0] == 'Y') {
return;
} else {
fprintf(stderr, abandoned);
cleanup_exit(0);
}
}
void setEcho(int flag)
{
#ifdef WINDOWS
HANDLE hConsole;
DWORD dwMode;
hConsole = CreateFile("CONIN$",
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
0,
NULL);
if(hConsole != INVALID_HANDLE_VALUE) {
GetConsoleMode(hConsole, &dwMode);
if(flag) {
dwMode |= ENABLE_ECHO_INPUT;
} else {
dwMode &= ~ENABLE_ECHO_INPUT;
}
SetConsoleMode(hConsole, dwMode);
CloseHandle(hConsole);
}
#else /* unix */
static struct termios init_set;
static int initialized = 0;
struct termios new_set;
if(initialized == 0) {
tcgetattr(fileno(stdin), &init_set);
initialized = 1;
}
new_set = init_set;
if(flag) {
tcsetattr(fileno(stdin), TCSAFLUSH, &init_set);
} else {
new_set.c_lflag &= ~ECHO;
tcsetattr(fileno(stdin), TCSAFLUSH, &new_set);
}
#endif
}
int simple_get_pass(char* passwd, size_t max_size){
int ret = 0;
#if defined HAVE_TERMIOS_H
struct termios old_term, new_term;
FILE* stream = stdin;
/* Turn echoing off and fail if we can't. */
if (tcgetattr (fileno (stream), &old_term) != 0)
return -1;
new_term = old_term;
new_term.c_lflag &= ~ECHO;
if (tcsetattr (fileno (stream), TCSAFLUSH, &new_term) != 0)
return -1;
/* Read the password. */
std::cin.getline(passwd, max_size);
ret = strlen(passwd);
/* Restore terminal. */
(void) tcsetattr (fileno (stream), TCSAFLUSH, &old_term);
#elif HAVE_SETCONSOLEMODE
HANDLE hstdin = GetStdHandle(STD_INPUT_HANDLE);
DWORD mode;
if (!GetConsoleMode(hstdin, &mode))
return -1;
if (hstdin == INVALID_HANDLE_VALUE || !(SetConsoleMode(hstdin, 0)))
return -1;
std::cin.getline(passwd, max_size);
ret = strlen(passwd);
if (!SetConsoleMode(hstdin, mode))
return -1;
#else
char* p;
if((p = getpass("")) == NULL)
return -1;
*passwd = strdup(p);
ret = strlen(p);
#endif
return ret;
}
static int enableRawMode(struct current *current) {
DWORD n;
INPUT_RECORD irec;
current->outh = GetStdHandle(STD_OUTPUT_HANDLE);
current->inh = GetStdHandle(STD_INPUT_HANDLE);
if (!PeekConsoleInput(current->inh, &irec, 1, &n)) {
return -1;
}
if (getWindowSize(current) != 0) {
return -1;
}
if (GetConsoleMode(current->inh, &orig_consolemode)) {
SetConsoleMode(current->inh, ENABLE_PROCESSED_INPUT);
}
return 0;
}
void qemu_set_tty_echo(int fd, bool echo)
{
HANDLE handle = (HANDLE)_get_osfhandle(fd);
DWORD dwMode = 0;
if (handle == INVALID_HANDLE_VALUE) {
return;
}
GetConsoleMode(handle, &dwMode);
if (echo) {
SetConsoleMode(handle, dwMode | ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT);
} else {
SetConsoleMode(handle,
dwMode & ~(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT));
}
}
void init_console(void)
{
int Mode;
struct _CONSOLE_SCREEN_BUFFER_INFO sbi;
HANDLE Hstd;
FILE *stream;
Hstd = GetStdHandle(STD_INPUT_HANDLE);
AllocConsole();
GetConsoleMode(Hstd, (LPDWORD)&Mode);
SetConsoleMode(Hstd, Mode & 0xFFFFFFEF);
GetConsoleScreenBufferInfo(Hstd, &sbi);
sbi.dwSize.Y = 4096;
SetConsoleScreenBufferSize(Hstd, sbi.dwSize);
freopen_s(&stream, "conin$", "r", stdin);
freopen_s(&stream, "conout$", "w", stdout);
freopen_s(&stream, "conout$", "w", stderr);
}
static int disable_echo(void)
{
hconin = CreateFile("CONIN$", GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
if (hconin == INVALID_HANDLE_VALUE)
return -1;
GetConsoleMode(hconin, &cmode);
sigchain_push_common(restore_term_on_signal);
if (!SetConsoleMode(hconin, cmode & (~ENABLE_ECHO_INPUT))) {
CloseHandle(hconin);
hconin = INVALID_HANDLE_VALUE;
return -1;
}
return 0;
}
static void installsighandler()
{
#ifndef _WIN32
signal(SIGHUP,sighandler);
signal(SIGUSR1,sighandler);
signal(SIGPIPE,sighandler);
#endif
signal(SIGINT,sighandler);
#ifdef _WIN32
SetConsoleCtrlHandler(ConsoleCtrlHandler,true);
HANDLE hs=GetStdHandle(STD_INPUT_HANDLE);
DWORD mode;
if (GetConsoleMode(hs,&mode)) {
mode|=ENABLE_PROCESSED_INPUT;
SetConsoleMode(hs,mode);
};
#endif
}
