ssize_t
read_win32(int fildes, void *buf, size_t nbyte)
{
DWORD val=0;
DWORD filetype = GetFileType((HANDLE) fildes);
if (fildes == fileno(stdin))
{
ReadConsole(GetStdHandle(STD_INPUT_HANDLE), buf, nbyte, &val, NULL);
}
else if (filetype == FILE_TYPE_DISK)
{
ReadFile((HANDLE)fildes, buf, nbyte, &val, NULL);
}
else if (filetype == FILE_TYPE_CHAR)
{
ReadConsole(GetStdHandle(STD_INPUT_HANDLE), buf, nbyte, &val, NULL);
}
else
{
OVERLAPPED overlap;
overlap.hEvent = (HANDLE)NULL;
if (ReadFile((HANDLE) fildes, buf, nbyte, &val, &overlap)==FALSE)
{
if (!GetOverlappedResult((HANDLE) fildes, &overlap, &val, TRUE))
{
const DWORD error = GetLastError();
cerr << "read_win32, error is: " << error << " - "
<< " - " << fildes << endl;
}
}
}
return val;
}
std::tstring Console::ReadLine(void)
{
std::vector<tchar_t> accumulator; // Character accumulator
DWORD mode = 0; // Original console mode
DWORD read = 0; // Characters read from the console
tchar_t next; // Next character read from console
// Prevent multiple threads from reading the console at the same time
std::lock_guard<std::recursive_mutex> lock(m_readlock);
// Ensure LINE_INPUT and ECHO_INPUT are enabled for the input mode
if(!GetConsoleMode(m_stdin, &mode)) throw Win32Exception();
if(!SetConsoleMode(m_stdin, mode | ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT)) throw Win32Exception();
try {
// Repeatedly read characters from the console until CR has been detected
if(!ReadConsole(m_stdin, &next, 1, &read, nullptr)) throw Win32Exception();
while(next != _T('\n')) {
if(next != _T('\r')) accumulator.push_back(next);
if(!ReadConsole(m_stdin, &next, 1, &read, nullptr)) throw Win32Exception();
}
}
// Be sure the restore the original console mode flags on any exception
catch(...) { SetConsoleMode(m_stdin, mode); throw; }
// Restore the previously set input mode flags
SetConsoleMode(m_stdin, mode);
// Convert the accumulated character data as a tstring instance
return std::tstring(accumulator.data(), accumulator.size());
}
/*-----------------------------------------------------------------------------
SetUserThreshold(IDiskQuotaControl* lpDiskQuotaControl)
Set the warning threshold limit for a specific user
Parameters
lpDiskQuotaControl - Pointer to an object that implements the
IDiskQuotaControl interface
Return Value
TRUE - Success
FALSE - Failure
-----------------------------------------------------------------------------*/
BOOL SetUserThreshold(IDiskQuotaControl* lpDiskQuotaControl)
{
HRESULT hr;
IDiskQuotaUser* lpDiskQuotaUser;
WCHAR szUser[MAX_PATH] = {0};
DWORD dwCharsRead;
LONGLONG llLimit = 0;
HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE);
wprintf(L"\n\nEnter the logon name of the user ");
wprintf(L"(ie. DOMAIN\\USERNAME): ");
// Get the user for which to set a hard limit
ReadConsole(hStdIn, szUser, MAX_PATH, &dwCharsRead, NULL);
szUser[MAX_PATH-1] = L'\0'; // make sure szUSer is NULL terminated
// Strip the line feed and carriage return
LfcrToNull(szUser);
// Check if the name is valid
hr = lpDiskQuotaControl->FindUserName((LPCWSTR)szUser, &lpDiskQuotaUser);
if (SUCCEEDED(hr))
{
WCHAR szLimit[MAX_PATH] = {0};
wprintf(L"\nEnter the new hard limit in bytes (-1 == No Limit): ");
// Read the threshold from the console
ReadConsole(hStdIn, szLimit, MAX_PATH, &dwCharsRead, NULL);
LfcrToNull(szLimit);
llLimit = _wtoi64(szLimit);
if (llLimit >= -1)
{
// Set the warning threshold for the user
hr = lpDiskQuotaUser->SetQuotaThreshold(llLimit, TRUE);
if (FAILED(hr))
{
wprintf(L"\nCould not set the quota limit for %s", szUser);
wprintf(L"to %i64 bytes\n", llLimit);
}
}
else
{
wprintf(L"\nInvalid limit!");
}
lpDiskQuotaUser->Release();
}
else
{
PrintError(hr);
}
return SUCCEEDED(hr);
}
JNIEXPORT jstring JNICALL Java_com_yifanlu_Josh_Josh_READCONSOLE
(JNIEnv *env, jclass jcls, jlong pointer)
{
HANDLE hIn = pointerToHandle(pointer);
char ReadBuffer[1024] = {0};
DWORD dwBytesRead = 0;
ReadConsole(hIn, &ReadBuffer, 1024, &dwBytesRead, NULL);
char input[1024];
int count = 0;
for(int i=0; i<1024; i++)
if(ReadBuffer[i] != '\0' && count < dwBytesRead)
{
input[count] = ReadBuffer[i];
count++;
}
int len = dwBytesRead - 2;
jchar* unicodeChars = new jchar[len];
for (int i=0; i<len; i++)
unicodeChars[i] = input[i];
jstring jInput = env->NewString(unicodeChars, len);
delete[] unicodeChars;
return jInput;
}
globle int gengetchar(
void *theEnv)
{
#if WIN_BTC || WIN_MVC
if (SystemDependentData(theEnv)->getcLength ==
SystemDependentData(theEnv)->getcPosition)
{
TCHAR tBuffer = 0;
DWORD count = 0;
WCHAR wBuffer = 0;
ReadConsole(GetStdHandle(STD_INPUT_HANDLE),&tBuffer,1,&count,NULL);
wBuffer = tBuffer;
SystemDependentData(theEnv)->getcLength =
WideCharToMultiByte(CP_UTF8,0,&wBuffer,1,
(char *) SystemDependentData(theEnv)->getcBuffer,
7,NULL,NULL);
SystemDependentData(theEnv)->getcPosition = 0;
}
return SystemDependentData(theEnv)->getcBuffer[SystemDependentData(theEnv)->getcPosition++];
#else
return(getc(stdin));
#endif
}
/*-----------------------------------------------------------------------------
AddUser(IDiskQuotaControl* lpDiskQuotaControl)
Add a user for which to track quota data
Parameters
lpDiskQuotaControl - Pointer to an object that implements the
IDiskQuotaControl interface
Return Value
TRUE - Success
FALSE - Failure
-----------------------------------------------------------------------------*/
BOOL AddUser(IDiskQuotaControl* lpDiskQuotaControl)
{
HRESULT hr;
IDiskQuotaUser* lpDiskQuotaUser;
WCHAR szUser[MAX_PATH] = {0};
DWORD dwCharsRead;
HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE);
wprintf(L"\n\nEnter the logon name of the user (ie. DOMAIN\\USERNAME): ");
// Get the user for which to track quota information
ReadConsole(hStdIn, szUser, MAX_PATH, &dwCharsRead, NULL);
LfcrToNull(szUser);
// Add the user
hr = lpDiskQuotaControl->AddUserName(szUser,
DISKQUOTA_USERNAME_RESOLVE_SYNC,
&lpDiskQuotaUser);
if (FAILED(hr))
{
PrintError(hr);
return FALSE;
}
lpDiskQuotaUser->Release();
return TRUE;
}
/*
* read-wrapper to support reading from stdin on Windows.
*/
static ssize_t read_wincon(int fd, void *buf, size_t count)
{
HANDLE handle = NULL;
DWORD mode, rcount = 0;
BOOL success;
if(fd == fileno(stdin)) {
handle = GetStdHandle(STD_INPUT_HANDLE);
}
else {
return read(fd, buf, count);
}
if(GetConsoleMode(handle, &mode)) {
success = ReadConsole(handle, buf, curlx_uztoul(count), &rcount, NULL);
}
else {
success = ReadFile(handle, buf, curlx_uztoul(count), &rcount, NULL);
}
if(success) {
return rcount;
}
errno = GetLastError();
return -1;
}
static BOOL
ReadConsoleBytes(
HANDLE hConsole,
LPVOID lpBuffer,
DWORD nbytes,
LPDWORD nbytesread)
{
DWORD ntchars;
BOOL result;
int tcharsize = sizeof(TCHAR);
/*
* If user types a Ctrl-Break or Ctrl-C, ReadConsole will return
* success with ntchars == 0 and GetLastError() will be
* ERROR_OPERATION_ABORTED. We do not want to treat this case
* as EOF so we will loop around again. If no Ctrl signal handlers
* have been established, the default signal OS handler in a separate
* thread will terminate the program. If a Ctrl signal handler
* has been established (through an extension for example), it
* will run and take whatever action it deems appropriate.
*/
do {
result = ReadConsole(hConsole, lpBuffer, nbytes / tcharsize, &ntchars,
NULL);
} while (result && ntchars == 0 && GetLastError() == ERROR_OPERATION_ABORTED);
if (nbytesread != NULL) {
*nbytesread = ntchars * tcharsize;
}
return result;
}
static DWORD WINAPI input_thread(LPVOID arg)
{
struct ui_st *st = arg;
/* Switch to raw mode */
SetConsoleMode(st->hstdin, 0);
while (st->run) {
char buf[4];
DWORD i, count = 0;
ReadConsole(st->hstdin, buf, sizeof(buf), &count, NULL);
for (i=0; i<count; i++) {
int ch = buf[i];
if (ch == '\r')
ch = '\n';
/*
* The keys are read from a thread so we have
* to send them to the RE main event loop via
* a message queue
*/
mqueue_push(st->mq, ch, 0);
}
}
return 0;
}
R_API int r_cons_readchar() {
void *bed;
char buf[2];
buf[0] = -1;
if (readbuffer_length > 0) {
int ch = *readbuffer;
readbuffer_length--;
memmove (readbuffer, readbuffer + 1, readbuffer_length);
return ch;
}
#if __WINDOWS__ && !__CYGWIN__ //&& !MINGW32
#if 1 // if something goes wrong set this to 0. skuater.....
return readchar_win(0);
#endif
BOOL ret;
DWORD out;
DWORD mode;
HANDLE h = GetStdHandle (STD_INPUT_HANDLE);
GetConsoleMode (h, &mode);
SetConsoleMode (h, 0); // RAW
bed = r_cons_sleep_begin ();
ret = ReadConsole (h, buf, 1, &out, NULL);
r_cons_sleep_end (bed);
FlushConsoleInputBuffer (h);
if (!ret) {
return -1;
}
SetConsoleMode (h, mode);
#else
r_cons_set_raw (1);
bed = r_cons_sleep_begin ();
// Blocks until either stdin has something to read or a signal happens.
// This serves to check if the terminal window was resized. It avoids the race
// condition that could happen if we did not use pselect or select in case SIGWINCH
// was handled immediately before the blocking call (select or read). The race is
// prevented from happening by having SIGWINCH blocked process-wide except for in
// pselect (that is what pselect is for).
fd_set readfds;
sigset_t sigmask;
FD_ZERO (&readfds);
FD_SET (STDIN_FILENO, &readfds);
r_signal_sigmask (0, NULL, &sigmask);
sigdelset (&sigmask, SIGWINCH);
pselect (STDIN_FILENO + 1, &readfds, NULL, NULL, NULL, &sigmask);
if (sigwinchFlag != 0) {
resizeWin ();
}
ssize_t ret = read (STDIN_FILENO, buf, 1);
r_cons_sleep_end (bed);
if (ret != 1) {
return -1;
}
if (bufactive) {
r_cons_set_raw (0);
}
#endif
return r_cons_controlz (buf[0]);
}
/**
* Very simplistic console input
*/
static void console_input(void)
{
TCHAR inp;
DWORD read;
if(!ReadConsole(events[1], &inp, 1, &read, NULL))
return;
switch(inp) {
case 8:
if(console_ptr > 0) {
console_ptr--;
printf("\b \b");
}
break;
case 13:
printf("\n\r");
console_buf[console_ptr++] = 0;
console_ptr = 0;
enable_console = 0;
cmd_exec_unparsed(console_buf);
break;
default:
if(console_ptr < sizeof(console_buf) - 1) {
printf("%c", (char)inp);
console_buf[console_ptr++] = inp;
}
break;
}
}
static void GetPasswordText(wchar *Str,uint MaxLength)
{
if (MaxLength==0)
return;
#ifdef _WIN_ALL
HANDLE hConIn=GetStdHandle(STD_INPUT_HANDLE);
HANDLE hConOut=GetStdHandle(STD_OUTPUT_HANDLE);
DWORD ConInMode,ConOutMode;
DWORD Read=0;
GetConsoleMode(hConIn,&ConInMode);
GetConsoleMode(hConOut,&ConOutMode);
SetConsoleMode(hConIn,ENABLE_LINE_INPUT);
SetConsoleMode(hConOut,ENABLE_PROCESSED_OUTPUT|ENABLE_WRAP_AT_EOL_OUTPUT);
ReadConsole(hConIn,Str,MaxLength-1,&Read,NULL);
Str[Read]=0;
SetConsoleMode(hConIn,ConInMode);
SetConsoleMode(hConOut,ConOutMode);
#else
char StrA[MAXPASSWORD];
#if defined(_EMX) || defined (__VMS) || defined(__AROS__)
fgets(StrA,ASIZE(StrA)-1,stdin);
#elif defined(__sun)
strncpyz(StrA,getpassphrase(""),ASIZE(StrA));
#else
strncpyz(StrA,getpass(""),ASIZE(StrA));
#endif
CharToWide(StrA,Str,MaxLength);
cleandata(StrA,sizeof(StrA));
#endif
Str[MaxLength-1]=0;
RemoveLF(Str);
}
R_API int r_cons_readchar() {
char buf[2];
buf[0] = -1;
#if __WINDOWS__ && !__CYGWIN__ //&& !MINGW32
#if 1 // if something goes wrong set this to 0. skuater.....
return readchar_win(0);
#endif
BOOL ret;
DWORD out;
DWORD mode;
HANDLE h = GetStdHandle (STD_INPUT_HANDLE);
GetConsoleMode (h, &mode);
SetConsoleMode (h, 0); // RAW
ret = ReadConsole (h, buf, 1, &out, NULL);
FlushConsoleInputBuffer (h);
if (!ret) {
return -1;
}
SetConsoleMode (h, mode);
#else
r_cons_set_raw (1);
if (read (0, buf, 1) == -1) {
return -1;
}
r_cons_set_raw (0);
#endif
return r_cons_controlz (buf[0]);
}
INPUT_RECORD *TThreads::get_next_event(void) {
if (evpending) return &ir;
PeekConsoleInput(chandle[cnInput],&ir,1,&evpending);
if (evpending) {
int code = event_type(ir);
// printf("evtype = %d\n",code);
switch (code) {
case IO_RAW_EVENT:
ReadConsoleInput(chandle[cnInput],&ir,1,&evpending);
break;
case IO_CHR_EVENT:
char chr;
// printf("before readconsole\n");
ReadConsole(chandle[cnInput],&chr,1,&evpending,NULL);
// printf("key %x %d\n",chr,evpending);
ir.Event.KeyEvent.uChar.AsciiChar = chr;
break;
case IO_IGN_EVENT:
ReadConsoleInput(chandle[cnInput],&ir,1,&evpending);
accept_event();
break;
}
}
return evpending ? &ir : NULL;
}
/*-----------------------------------------------------------------------------
SetDefaultThreshold(IDiskQuotaControl* lpDiskQuotaControl)
Set the default warning threshold of the volume.
Parameters
lpDiskQuotaControl - Pointer to an object that implements the
IDiskQuotaControl interface
Return Value
TRUE - Success
FALSE - Failure
-----------------------------------------------------------------------------*/
BOOL SetDefaultThreshold(IDiskQuotaControl* lpDiskQuotaControl)
{
HRESULT hr;
LONGLONG llLimit = 0;
WCHAR szLimit[MAX_PATH] = {0};
DWORD dwCharsRead;
HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE);
wprintf(L"\n\nEnter the new default threshold in Bytes ");
wprintf(L"(-1 == No Limit): ");
// Get the limit from the command prompt
ReadConsole(hStdIn, szLimit, MAX_PATH, &dwCharsRead, NULL);
LfcrToNull(szLimit);
llLimit = _wtoi64(szLimit);
if (llLimit < -1)
{
wprintf(L"\nInvalid limit!");
return FALSE;
}
// Set the default warning threshold
hr = lpDiskQuotaControl->SetDefaultQuotaThreshold(llLimit);
if (FAILED(hr))
{
PrintError(hr);
return FALSE;
}
return TRUE;
}
static int
read_win32_console_input(void)
{
INPUT_RECORD rec;
DWORD nevents;
if (PeekConsoleInput(hConIn, &rec, 1, &nevents) && nevents) {
switch (rec.EventType) {
case KEY_EVENT:
expand_win32_console_input_buffer(3);
if (ReadConsole(hConIn, &ConInV[nConIn], 1, &nevents, NULL)) {
nConIn += nevents;
return nevents;
}
break;
default:
break;
}
ReadConsoleInput(hConIn, &rec, 1, &nevents);
}
return 0;
}
void ConsoleProc()
{
CHAR byte;
DWORD read;
while ( ReadConsole( hConIn, &byte, 1, &read, NULL) )
{
if ( byte == 'C' || byte == 'c' )
{
COORD coordScreen = { 0, 0 };
FillConsoleOutputCharacter(hConOut,' ', 0xFFFFFFFF, coordScreen, &read);
SetConsoleCursorPosition(hConOut, coordScreen);
}
else if ( byte == 'W' || byte == 'w' )
{
Scanner::TPattern WardenPattern ("\x56\x57\xFC\x8B\x54\x24\x14\x8B\x74\x24\x10\x8B\x44\x24\x0C\x8B\xCA\x8B\xF8\xC1\xE9\x02\x74\x02\xF3\xA5" \
"\xB1\x03\x23\xCA\x74\x02\xF3\xA4\x5F\x5E\xC3", "x37");
DWORD WardenProc = (DWORD) Scanner::ScanMem( &WardenPattern );
if ( WardenProc )
{
Logger::OutLog("Warden::Scan proc:0x%.8x\r\n", WardenProc);
}
else
Logger::OutLog("Warden::Scan proc not found\r\n");
}
}
}
///////////////////////////////////////////////////////////////////////
// GetAndSendInputThreadOrig
// Thread procedure that monitors the console for input and sends input
// to the child process through the input pipe.
// This thread ends when the child application exits.
// Original from http://support.microsoft.com/kb/190351
///////////////////////////////////////////////////////////////////////
DWORD WINAPI GetAndSendInputThreadOrig(LPVOID lpvThreadParam)
{
CHAR read_buff[256];
DWORD nBytesRead,nBytesWrote;
HANDLE hPipeWrite = (HANDLE)lpvThreadParam;
// Get input from our console and send it to child through the pipe.
while (bRunThread)
{
if(!ReadConsole(hStdIn,read_buff,1,&nBytesRead,NULL))
DisplayError("ReadConsole");
read_buff[nBytesRead] = '\0'; // Follow input with a NULL.
if (!WriteFile(hPipeWrite,read_buff,nBytesRead,&nBytesWrote,NULL))
{
if (GetLastError() == ERROR_NO_DATA)
break; // Pipe was closed (normal exit path).
else
DisplayError("WriteFile");
}
}
return 1;
}
static void ConsoleWriteReadDefault(LPSTR pReadBuf, DWORD lenReadBuf, LPCSTR pText)
{
static HANDLE handle = INVALID_HANDLE_VALUE;
if (handle == INVALID_HANDLE_VALUE) {
AllocConsole();
handle = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTitle(title);
isConsoleOpen = TRUE;
}
if (pText) {
DWORD cnt;
if (GetFileType(handle) == FILE_TYPE_CHAR)
WriteConsole(handle, pText, lstrlen(pText), &cnt, NULL);
else
WriteFile(handle, pText, lstrlen(pText), &cnt, NULL);
}
if (pReadBuf && lenReadBuf > 0) {
if (lenReadBuf > 1 &&
ReadConsole(GetStdHandle(STD_INPUT_HANDLE), pReadBuf, lenReadBuf - 1, &lenReadBuf, 0))
{
pReadBuf[lenReadBuf] = 0;
} else {
pReadBuf[0] = 0;
}
}
}
static DWORD WINAPI
getInput(LPVOID h)
{ input_context *ctx = h;
ctx->rc = ReadConsole(ctx->input, ctx->buf, ctx->len, &ctx->done, NULL);
return ctx->rc;
}
void DebugConsole::waitKey()
{
INPUT_RECORD record;
DWORD rr;
writeline("--PRESS A KEY--");
SetConsoleMode(m_in,ENABLE_PROCESSED_INPUT);
ReadConsole(m_in, &record, 1, &rr, NULL);
}
tstring Console::read()
{
tchar input[1024];
DWORD numRead;
ReadConsole(inHandle_, input, 1023, &numRead, NULL);
input[numRead - 2] = KILLME_T('\0');
return input;
}
int cgetch()
{
char buffer[3];
DWORD chread;
ReadConsole(ConStdIn, buffer, sizeof(TCHAR), &chread, NULL);
return (int)buffer[0];
}
/*
* SfMain
*
* Purpose:
*
* Murasame main.
*
*/
void SfMain(
VOID
)
{
BOOL cond = FALSE;
UINT uResult = 0;
DWORD dwTemp;
HANDLE StdIn;
INPUT_RECORD inp1;
__security_init_cookie();
do {
g_ConOut = GetStdHandle(STD_OUTPUT_HANDLE);
if (g_ConOut == INVALID_HANDLE_VALUE) {
uResult = (UINT)-1;
break;
}
g_ConsoleOutput = TRUE;
if (!GetConsoleMode(g_ConOut, &dwTemp)) {
g_ConsoleOutput = FALSE;
}
SetConsoleTitle(T_SFEXTRACTTITLE);
SetConsoleMode(g_ConOut, ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_PROCESSED_OUTPUT);
if (g_ConsoleOutput == FALSE) {
WriteFile(g_ConOut, &BE, sizeof(WCHAR), &dwTemp, NULL);
}
if (SfInitGdiPlus()) {
uResult = SfExtractDropper(GetCommandLine());
}
else {
SfcuiPrintText(g_ConOut,
T_SFINITFAILED,
g_ConsoleOutput, FALSE);
}
if (g_ConsoleOutput) {
SfcuiPrintText(g_ConOut,
T_SFPRESSANYKEY,
TRUE, FALSE);
StdIn = GetStdHandle(STD_INPUT_HANDLE);
if (StdIn != INVALID_HANDLE_VALUE) {
RtlSecureZeroMemory(&inp1, sizeof(inp1));
ReadConsoleInput(StdIn, &inp1, 1, &dwTemp);
ReadConsole(StdIn, &BE, sizeof(BE), &dwTemp, NULL);
}
}
} while (cond);
ExitProcess(uResult);
}
/*-----------------------------------------------------------------------------
GetUserQuotaInfo(IDiskQuotaControl* lpDiskQuotaControl)
Get quota information for a specific user
Parameters
lpDiskQuotaControl - Pointer to an object that implements the
IDiskQuotaControl interface
Return Value
TRUE - Success
FALSE - Failure
-----------------------------------------------------------------------------*/
BOOL GetUserQuotaInfo(IDiskQuotaControl* lpDiskQuotaControl)
{
WCHAR szUser[MAX_PATH] = {0};
IDiskQuotaUser* lpDiskQuotaUser;
DWORD dwCharsRead;
HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE);
HRESULT hr;
wprintf(L"\n\nEnter the logon name of the user");
wprintf(L"(ie. DOMAIN\\USERNAME): ");
// Get the user for which to get quota information
ReadConsole(hStdIn, szUser, MAX_PATH, &dwCharsRead, NULL);
szUser[MAX_PATH-1] = L'\0'; // make sure szUser is NULL terminated
LfcrToNull(szUser);
// Check if the name is valid
hr = lpDiskQuotaControl->FindUserName((LPCWSTR)szUser, &lpDiskQuotaUser);
if (SUCCEEDED(hr))
{
WCHAR szQuotaUsedText[MAX_PATH] = {0};
WCHAR szQuotaLimitText[MAX_PATH] = {0};
WCHAR szQuotaThresholdText[MAX_PATH] = {0};
if (SUCCEEDED(hr = lpDiskQuotaUser->GetQuotaThresholdText(
szQuotaThresholdText, MAX_PATH)) &&
SUCCEEDED(hr = lpDiskQuotaUser->GetQuotaLimitText(
szQuotaLimitText, MAX_PATH)) &&
SUCCEEDED(hr = lpDiskQuotaUser->GetQuotaUsedText(
szQuotaUsedText, MAX_PATH)))
{
szQuotaUsedText[MAX_PATH-1] = L'\0'; // make sure szQuotaUsedText is NULL terminated
szQuotaLimitText[MAX_PATH-1] = L'\0'; // make sure szQuotaLimitText is NULL terminated
szQuotaThresholdText[MAX_PATH-1] = L'\0'; // make sure szQuotaThresholdText is NULL terminated
wprintf(L"Amount Used Limit Threshold\n");
wprintf(L"----------- ----- ---------\n");
wprintf(L" %10s", szQuotaUsedText);
wprintf(L" %10s", szQuotaLimitText);
wprintf(L" %10s", szQuotaThresholdText);
wprintf(L"\n");
}
else
{
wprintf(L"\nCould not get the quota information for %s", szUser);
}
lpDiskQuotaUser->Release();
}
else
{
wprintf(L"\nCould not find quota data for %s\n", szUser);
}
WaitForKeyPress();
return SUCCEEDED(hr);
}
// Console IO //////////////////////////////////////////////////
UInt System::ConsoleRead( GChar * outBuffer, UInt iMaxLength ) const
{
HANDLE hIn = GetStdHandle( STD_INPUT_HANDLE );
DebugAssert( hIn != INVALID_HANDLE_VALUE );
DWord iRead = 0;
BOOL bOk = ReadConsole( hIn, outBuffer, iMaxLength, &iRead, NULL );
DebugAssert( bOk && iRead >= 2 );
outBuffer[iRead-2] = NULLBYTE; // remove trailing cr/lf
return (UInt)iRead;
}
/* were just going to fake it here and get input from the keyboard */
void get_tty_password_buff(const char *opt_message, char *to, size_t length)
{
HANDLE consoleinput;
DWORD oldstate;
char *pos=to,*end=to+length-1;
int i=0;
consoleinput= CreateFile("CONIN$", GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ ,
NULL, OPEN_EXISTING, 0, NULL);
if (consoleinput == NULL || consoleinput == INVALID_HANDLE_VALUE)
{
/* This is a GUI application or service without console input, bail out. */
*to= 0;
return;
}
_cputs(opt_message ? opt_message : "Enter password: "******"\b \b");
pos--;
continue;
}
}
if (tmp == '\n' || tmp == '\r')
break;
if (iscntrl(tmp) || pos == end)
continue;
_cputs("*");
*(pos++) = tmp;
}
/* Reset console mode after password input. */
SetConsoleMode(consoleinput, oldstate);
CloseHandle(consoleinput);
*pos=0;
_cputs("\n");
}
int gets_quiet(char *s, int len)
{
#ifdef WIN32
HANDLE h;
DWORD con_orig, con_quiet;
DWORD read_len = 0;
memset(s, 0, len);
h = GetStdHandle(STD_INPUT_HANDLE);
GetConsoleMode(h, &con_orig);
con_quiet &= ~ENABLE_ECHO_INPUT;
con_quiet |= ENABLE_LINE_INPUT;
SetConsoleMode(h, con_quiet);
if(!ReadConsole(h, s, len, &read_len, NULL)){
SetConsoleMode(h, con_orig);
return 1;
}
while(s[strlen(s)-1] == 10 || s[strlen(s)-1] == 13){
s[strlen(s)-1] = 0;
}
if(strlen(s) == 0){
return 1;
}
SetConsoleMode(h, con_orig);
return 0;
#else
struct termios ts_quiet, ts_orig;
char *rs;
memset(s, 0, len);
tcgetattr(0, &ts_orig);
ts_quiet = ts_orig;
ts_quiet.c_lflag &= ~(ECHO | ICANON);
tcsetattr(0, TCSANOW, &ts_quiet);
rs = fgets(s, len, stdin);
tcsetattr(0, TCSANOW, &ts_orig);
if(!rs){
return 1;
}else{
while(s[strlen(s)-1] == 10 || s[strlen(s)-1] == 13){
s[strlen(s)-1] = 0;
}
if(strlen(s) == 0){
return 1;
}
}
return 0;
#endif
}
~WindowsAppConsoleOutput()
{
std::cout << std::endl << "Press any key to exit" << std::endl;
// Disable line-based input mode so we can get a single character
HANDLE ConsoleInput = GetStdHandle(STD_INPUT_HANDLE);
SetConsoleMode(ConsoleInput, 0);
// Read a single character
TCHAR InputBuffer;
DWORD CharsRead;
ReadConsole(ConsoleInput, &InputBuffer, 1, &CharsRead, 0);
}
char keyboard_char(void)
{
char buffer[1] ;
DWORD rbytes ;
if ( !ReadConsole(conin, buffer, 1, &rbytes, NULL) || rbytes != 1 )
error("Can't read character from console") ;
if ( buffer[0] == '\r' )
buffer[0] = '\n' ;
return buffer[0] ;
}
