/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Timeout utility
* FILE: base/applications/cmdutils/timeout/timeout.c
* PURPOSE: An enhanced alternative to the Pause command.
* PROGRAMMERS: Lee Schroeder (spaceseel at gmail dot com)
* Hermes Belusca-Maito (hermes.belusca@sfr.fr)
*/
#include <stdio.h>
#include <stdlib.h>
#include <windef.h>
#include <winbase.h>
#include <wincon.h>
#include <winuser.h>
#include <conutils.h>
#include "resource.h"
VOID PrintError(DWORD dwError)
{
if (dwError == ERROR_SUCCESS)
return;
ConMsgPuts(StdErr, FORMAT_MESSAGE_FROM_SYSTEM,
NULL, dwError, LANG_USER_DEFAULT);
ConPuts(StdErr, L"\n");
}
BOOL
WINAPI
CtrlCIntercept(DWORD dwCtrlType)
{
switch (dwCtrlType)
{
case CTRL_C_EVENT:
ConPuts(StdOut, L"\n");
SetConsoleCtrlHandler(NULL, FALSE);
ExitProcess(EXIT_FAILURE);
return TRUE;
}
return FALSE;
}
INT InputWait(BOOL bNoBreak, INT timerValue)
{
INT Status = EXIT_SUCCESS;
HANDLE hInput;
BOOL bUseTimer = (timerValue != -1);
HANDLE hTimer = NULL;
DWORD dwStartTime;
LONG timeElapsed;
DWORD dwWaitState;
INPUT_RECORD InputRecords[5];
ULONG NumRecords, i;
BOOL DisplayMsg = TRUE;
UINT WaitMsgId = (bNoBreak ? IDS_NOBREAK_INPUT : IDS_USER_INPUT);
UINT WaitCountMsgId = (bNoBreak ? IDS_NOBREAK_INPUT_COUNT : IDS_USER_INPUT_COUNT);
/* Retrieve the current input handle */
hInput = ConStreamGetOSHandle(StdIn);
if (hInput == INVALID_HANDLE_VALUE)
{
ConResPrintf(StdErr, IDS_ERROR_INVALID_HANDLE_VALUE, GetLastError());
return EXIT_FAILURE;
}
/* Start a new wait if we use the timer */
if (bNoBreak && bUseTimer)
{
hTimer = CreateWaitableTimer(NULL, TRUE, NULL);
if (hTimer == NULL)
{
/* A problem happened, bail out */
PrintError(GetLastError());
return EXIT_FAILURE;
}
}
if (bUseTimer)
dwStartTime = GetTickCount();
/* If /NOBREAK is used, monitor for Ctrl-C input */
if (bNoBreak)
SetConsoleCtrlHandler(CtrlCIntercept, TRUE);
/* Initially flush the console input queue to remove any pending events */
if (!GetNumberOfConsoleInputEvents(hInput, &NumRecords) ||
!FlushConsoleInputBuffer(hInput))
{
/* A problem happened, bail out */
PrintError(GetLastError());
Status = EXIT_FAILURE;
goto Quit;
}
ConPuts(StdOut, L"\n");
/* If the timer is not used, just show the message */
if (!bUseTimer)
{
ConPuts(StdOut, L"\r");
ConResPuts(StdOut, WaitMsgId);
}
while (TRUE)
{
/* Decrease the timer if we use it */
if (bUseTimer)
{
/*
* Compute how much time the previous operations took.
* This allows us in particular to take account for any time
* elapsed if something slowed down, or if the console has been
* paused in the meantime.
*/
timeElapsed = GetTickCount() - dwStartTime;
if (timeElapsed >= 1000)
{
/* Increase dwStartTime by steps of 1 second */
timeElapsed /= 1000;
dwStartTime += (1000 * timeElapsed);
if (timeElapsed <= timerValue)
timerValue -= timeElapsed;
else
timerValue = 0;
DisplayMsg = TRUE;
}
if (DisplayMsg)
{
ConPuts(StdOut, L"\r");
ConResPrintf(StdOut, WaitCountMsgId, timerValue);
ConPuts(StdOut, L" \b");
DisplayMsg = FALSE;
}
/* Stop when the timer reaches zero */
if (timerValue <= 0)
break;
}
/* If /NOBREAK is used, only allow Ctrl-C input which is handled by the console handler */
if (bNoBreak)
{
if (bUseTimer)
{
LARGE_INTEGER DueTime;
/* We use the timer: use a passive wait of maximum 1 second */
timeElapsed = GetTickCount() - dwStartTime;
if (timeElapsed < 1000)
{
/*
* For whatever reason, x86 MSVC generates a ntdll!_allmul
* call when using Int32x32To64(), instead of an imul
* instruction. This leads the linker to error that _allmul
* is missing, since we do not link against ntdll.
* Everything is however OK with GCC...
* We therefore use the __emul() intrinsic which does
* the correct job.
*/
DueTime.QuadPart = __emul(1000 - timeElapsed, -10000);
SetWaitableTimer(hTimer, &DueTime, 0, NULL, NULL, FALSE);
dwWaitState = WaitForSingleObject(hTimer, INFINITE);
/* Check whether the timer has been signaled */
if (dwWaitState != WAIT_OBJECT_0)
{
/* An error happened, bail out */
PrintError(GetLastError());
Status = EXIT_FAILURE;
break;
}
}
}
else
{
/* No timer is used: wait indefinitely */
Sleep(INFINITE);
}
continue;
}
/* /NOBREAK is not used, check for user key presses */
/*
* If the timer is used, use a passive wait of maximum 1 second
* while monitoring for incoming console input events, so that
* we are still able to display the timing count.
* Indeed, ReadConsoleInputW() indefinitely waits until an input
* event appears. ReadConsoleInputW() is however used to retrieve
* the input events where there are some, as well as for waiting
* indefinitely in case we do not use the timer.
*/
if (bUseTimer)
{
/* Wait a maximum of 1 second for input events */
timeElapsed = GetTickCount() - dwStartTime;
if (timeElapsed < 1000)
dwWaitState = WaitForSingleObject(hInput, 1000 - timeElapsed);
else
dwWaitState = WAIT_TIMEOUT;
/* Check whether the input event has been signaled, or a timeout happened */
if (dwWaitState == WAIT_TIMEOUT)
continue;
if (dwWaitState != WAIT_OBJECT_0)
{
/* An error happened, bail out */
PrintError(GetLastError());
Status = EXIT_FAILURE;
break;
}
/* Be sure there is something in the console input queue */
if (!PeekConsoleInputW(hInput, InputRecords, ARRAYSIZE(InputRecords), &NumRecords))
{
/* An error happened, bail out */
ConResPrintf(StdErr, IDS_ERROR_READ_INPUT, GetLastError());
Status = EXIT_FAILURE;
break;
}
if (NumRecords == 0)
continue;
}
/*
* Some events have been detected, pop them out from the input queue.
* In case we do not use the timer, wait indefinitely until an input
* event appears.
*/
if (!ReadConsoleInputW(hInput, InputRecords, ARRAYSIZE(InputRecords), &NumRecords))
{
/* An error happened, bail out */
ConResPrintf(StdErr, IDS_ERROR_READ_INPUT, GetLastError());
Status = EXIT_FAILURE;
break;
}
/* Check the input events for a key press */
for (i = 0; i < NumRecords; ++i)
{
/* Ignore any non-key event */
if (InputRecords[i].EventType != KEY_EVENT)
continue;
/* Ignore any system key event */
if ((InputRecords[i].Event.KeyEvent.wVirtualKeyCode == VK_CONTROL) ||
// (InputRecords[i].Event.KeyEvent.dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED )) ||
// (InputRecords[i].Event.KeyEvent.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) ||
(InputRecords[i].Event.KeyEvent.wVirtualKeyCode == VK_MENU))
{
continue;
}
/* This is a non-system key event, stop waiting */
goto Stop;
}
}
Stop:
ConPuts(StdOut, L"\n");
Quit:
if (bNoBreak)
SetConsoleCtrlHandler(NULL, FALSE);
if (bNoBreak && bUseTimer)
CloseHandle(hTimer);
return Status;
}
int wmain(int argc, WCHAR* argv[])
{
INT timerValue = -1;
PWCHAR pszNext;
BOOL bDisableInput = FALSE, fTimerFlags = 0;
int index = 0;
/* Initialize the Console Standard Streams */
ConInitStdStreams();
if (argc == 1)
{
ConResPrintf(StdOut, IDS_USAGE);
return EXIT_SUCCESS;
}
/* Parse the command line for options */
for (index = 1; index < argc; index++)
{
if (argv[index][0] == L'-' || argv[index][0] == L'/')
{
switch (towupper(argv[index][1]))
{
case L'?': /* Help */
{
ConResPrintf(StdOut, IDS_USAGE);
return EXIT_SUCCESS;
}
case L'T': /* Timer */
{
/* Consecutive /T switches are invalid */
if (fTimerFlags & 2)
{
ConResPrintf(StdErr, IDS_ERROR_ONE_TIME);
return EXIT_FAILURE;
}
/* Remember that a /T switch has been encountered */
fTimerFlags |= 2;
/* Go to the next (timer) value */
continue;
}
}
/* This flag is used to ignore any keyboard keys but Ctrl-C */
if (_wcsicmp(&argv[index][1], L"NOBREAK") == 0)
{
bDisableInput = TRUE;
/* Go to next value */
continue;
}
}
/* The timer value can also be specified without the /T switch */
/* Only one timer value is supported */
if (fTimerFlags & 1)
{
ConResPrintf(StdErr, IDS_ERROR_ONE_TIME);
return EXIT_FAILURE;
}
timerValue = wcstol(argv[index], &pszNext, 10);
if (*pszNext)
{
ConResPrintf(StdErr, IDS_ERROR_OUT_OF_RANGE);
return EXIT_FAILURE;
}
/* Remember that the timer value has been set */
fTimerFlags |= 1;
}
/* A timer value is mandatory in order to continue */
if (!(fTimerFlags & 1))
{
ConResPrintf(StdErr, IDS_ERROR_NO_TIMER_VALUE);
return EXIT_FAILURE;
}
/* Make sure the timer value is within range */
if ((timerValue < -1) || (timerValue > 99999))
{
ConResPrintf(StdErr, IDS_ERROR_OUT_OF_RANGE);
return EXIT_FAILURE;
}
return InputWait(bDisableInput, timerValue);
}