1 /*
2  * COPYRIGHT:       See COPYING in the top level directory
3  * PROJECT:         ReactOS Timeout utility
4  * FILE:            base/applications/cmdutils/timeout/timeout.c
5  * PURPOSE:         An enhanced alternative to the Pause command.
6  * PROGRAMMERS:     Lee Schroeder (spaceseel at gmail dot com)
7  *                  Hermes Belusca-Maito (hermes.belusca@sfr.fr)
8  */
9 
10 #include <stdio.h>
11 #include <stdlib.h>
12 
13 #include <windef.h>
14 #include <winbase.h>
15 #include <wincon.h>
16 #include <winuser.h>
17 
18 #include <conutils.h>
19 
20 #include "resource.h"
21 
22 VOID PrintError(DWORD dwError)
23 {
24     if (dwError == ERROR_SUCCESS)
25         return;
26 
27     ConMsgPuts(StdErr, FORMAT_MESSAGE_FROM_SYSTEM,
28                NULL, dwError, LANG_USER_DEFAULT);
29     ConPuts(StdErr, L"\n");
30 }
31 
32 BOOL
33 WINAPI
34 CtrlCIntercept(DWORD dwCtrlType)
35 {
36     switch (dwCtrlType)
37     {
38         case CTRL_C_EVENT:
39             ConPuts(StdOut, L"\n");
40             SetConsoleCtrlHandler(NULL, FALSE);
41             ExitProcess(EXIT_FAILURE);
42             return TRUE;
43     }
44     return FALSE;
45 }
46 
47 INT InputWait(BOOL bNoBreak, INT timerValue)
48 {
49     INT Status = EXIT_SUCCESS;
50     HANDLE hInput;
51     BOOL bUseTimer = (timerValue != -1);
52     HANDLE hTimer = NULL;
53     DWORD dwStartTime;
54     LONG timeElapsed;
55     DWORD dwWaitState;
56     INPUT_RECORD InputRecords[5];
57     ULONG NumRecords, i;
58     BOOL DisplayMsg = TRUE;
59     UINT WaitMsgId = (bNoBreak ? IDS_NOBREAK_INPUT : IDS_USER_INPUT);
60     UINT WaitCountMsgId = (bNoBreak ? IDS_NOBREAK_INPUT_COUNT : IDS_USER_INPUT_COUNT);
61 
62     /* Retrieve the current input handle */
63     hInput = ConStreamGetOSHandle(StdIn);
64     if (hInput == INVALID_HANDLE_VALUE)
65     {
66         ConResPrintf(StdErr, IDS_ERROR_INVALID_HANDLE_VALUE, GetLastError());
67         return EXIT_FAILURE;
68     }
69 
70     /* Start a new wait if we use the timer */
71     if (bNoBreak && bUseTimer)
72     {
73         hTimer = CreateWaitableTimer(NULL, TRUE, NULL);
74         if (hTimer == NULL)
75         {
76             /* A problem happened, bail out */
77             PrintError(GetLastError());
78             return EXIT_FAILURE;
79         }
80     }
81     if (bUseTimer)
82         dwStartTime = GetTickCount();
83 
84     /* If /NOBREAK is used, monitor for Ctrl-C input */
85     if (bNoBreak)
86         SetConsoleCtrlHandler(CtrlCIntercept, TRUE);
87 
88     /* Initially flush the console input queue to remove any pending events */
89     if (!GetNumberOfConsoleInputEvents(hInput, &NumRecords) ||
90         !FlushConsoleInputBuffer(hInput))
91     {
92         /* A problem happened, bail out */
93         PrintError(GetLastError());
94         Status = EXIT_FAILURE;
95         goto Quit;
96     }
97 
98     ConPuts(StdOut, L"\n");
99 
100     /* If the timer is not used, just show the message */
101     if (!bUseTimer)
102     {
103         ConPuts(StdOut, L"\r");
104         ConResPuts(StdOut, WaitMsgId);
105     }
106 
107     while (TRUE)
108     {
109         /* Decrease the timer if we use it */
110         if (bUseTimer)
111         {
112             /*
113              * Compute how much time the previous operations took.
114              * This allows us in particular to take account for any time
115              * elapsed if something slowed down, or if the console has been
116              * paused in the meantime.
117              */
118             timeElapsed = GetTickCount() - dwStartTime;
119             if (timeElapsed >= 1000)
120             {
121                 /* Increase dwStartTime by steps of 1 second */
122                 timeElapsed /= 1000;
123                 dwStartTime += (1000 * timeElapsed);
124 
125                 if (timeElapsed <= timerValue)
126                     timerValue -= timeElapsed;
127                 else
128                     timerValue = 0;
129 
130                 DisplayMsg = TRUE;
131             }
132 
133             if (DisplayMsg)
134             {
135                 ConPuts(StdOut, L"\r");
136                 ConResPrintf(StdOut, WaitCountMsgId, timerValue);
137                 ConPuts(StdOut, L" \b");
138 
139                 DisplayMsg = FALSE;
140             }
141 
142             /* Stop when the timer reaches zero */
143             if (timerValue <= 0)
144                 break;
145         }
146 
147         /* If /NOBREAK is used, only allow Ctrl-C input which is handled by the console handler */
148         if (bNoBreak)
149         {
150             if (bUseTimer)
151             {
152                 LARGE_INTEGER DueTime;
153 
154                 /* We use the timer: use a passive wait of maximum 1 second */
155                 timeElapsed = GetTickCount() - dwStartTime;
156                 if (timeElapsed < 1000)
157                 {
158                     DueTime.QuadPart = Int32x32To64(1000 - timeElapsed, -10000);
159                     SetWaitableTimer(hTimer, &DueTime, 0, NULL, NULL, FALSE);
160                     dwWaitState = WaitForSingleObject(hTimer, INFINITE);
161 
162                     /* Check whether the timer has been signaled */
163                     if (dwWaitState != WAIT_OBJECT_0)
164                     {
165                         /* An error happened, bail out */
166                         PrintError(GetLastError());
167                         Status = EXIT_FAILURE;
168                         break;
169                     }
170                 }
171             }
172             else
173             {
174                 /* No timer is used: wait indefinitely */
175                 Sleep(INFINITE);
176             }
177 
178             continue;
179         }
180 
181         /* /NOBREAK is not used, check for user key presses */
182 
183         /*
184          * If the timer is used, use a passive wait of maximum 1 second
185          * while monitoring for incoming console input events, so that
186          * we are still able to display the timing count.
187          * Indeed, ReadConsoleInputW() indefinitely waits until an input
188          * event appears. ReadConsoleInputW() is however used to retrieve
189          * the input events where there are some, as well as for waiting
190          * indefinitely in case we do not use the timer.
191          */
192         if (bUseTimer)
193         {
194             /* Wait a maximum of 1 second for input events */
195             timeElapsed = GetTickCount() - dwStartTime;
196             if (timeElapsed < 1000)
197                 dwWaitState = WaitForSingleObject(hInput, 1000 - timeElapsed);
198             else
199                 dwWaitState = WAIT_TIMEOUT;
200 
201             /* Check whether the input event has been signaled, or a timeout happened */
202             if (dwWaitState == WAIT_TIMEOUT)
203                 continue;
204             if (dwWaitState != WAIT_OBJECT_0)
205             {
206                 /* An error happened, bail out */
207                 PrintError(GetLastError());
208                 Status = EXIT_FAILURE;
209                 break;
210             }
211 
212             /* Be sure there is something in the console input queue */
213             if (!PeekConsoleInputW(hInput, InputRecords, ARRAYSIZE(InputRecords), &NumRecords))
214             {
215                 /* An error happened, bail out */
216                 ConResPrintf(StdErr, IDS_ERROR_READ_INPUT, GetLastError());
217                 Status = EXIT_FAILURE;
218                 break;
219             }
220 
221             if (NumRecords == 0)
222                 continue;
223         }
224 
225         /*
226          * Some events have been detected, pop them out from the input queue.
227          * In case we do not use the timer, wait indefinitely until an input
228          * event appears.
229          */
230         if (!ReadConsoleInputW(hInput, InputRecords, ARRAYSIZE(InputRecords), &NumRecords))
231         {
232             /* An error happened, bail out */
233             ConResPrintf(StdErr, IDS_ERROR_READ_INPUT, GetLastError());
234             Status = EXIT_FAILURE;
235             break;
236         }
237 
238         /* Check the input events for a key press */
239         for (i = 0; i < NumRecords; ++i)
240         {
241             /* Ignore any non-key event */
242             if (InputRecords[i].EventType != KEY_EVENT)
243                 continue;
244 
245             /* Ignore any system key event */
246             if ((InputRecords[i].Event.KeyEvent.wVirtualKeyCode == VK_CONTROL) ||
247              // (InputRecords[i].Event.KeyEvent.dwControlKeyState & (LEFT_ALT_PRESSED  | RIGHT_ALT_PRESSED )) ||
248              // (InputRecords[i].Event.KeyEvent.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) ||
249                 (InputRecords[i].Event.KeyEvent.wVirtualKeyCode == VK_MENU))
250             {
251                 continue;
252             }
253 
254             /* This is a non-system key event, stop waiting */
255             goto Stop;
256         }
257     }
258 
259 Stop:
260     ConPuts(StdOut, L"\n");
261 
262 Quit:
263     if (bNoBreak)
264         SetConsoleCtrlHandler(NULL, FALSE);
265 
266     if (bNoBreak && bUseTimer)
267         CloseHandle(hTimer);
268 
269     return Status;
270 }
271 
272 int wmain(int argc, WCHAR* argv[])
273 {
274     INT timerValue = -1;
275     PWCHAR pszNext;
276     BOOL bDisableInput = FALSE, fTimerFlags = 0;
277     int index = 0;
278 
279     /* Initialize the Console Standard Streams */
280     ConInitStdStreams();
281 
282     if (argc == 1)
283     {
284         ConResPrintf(StdOut, IDS_USAGE);
285         return EXIT_SUCCESS;
286     }
287 
288     /* Parse the command line for options */
289     for (index = 1; index < argc; index++)
290     {
291         if (argv[index][0] == L'-' || argv[index][0] == L'/')
292         {
293             switch (towupper(argv[index][1]))
294             {
295                 case L'?': /* Help */
296                 {
297                     ConResPrintf(StdOut, IDS_USAGE);
298                     return EXIT_SUCCESS;
299                 }
300 
301                 case L'T': /* Timer */
302                 {
303                     /* Consecutive /T switches are invalid */
304                     if (fTimerFlags & 2)
305                     {
306                         ConResPrintf(StdErr, IDS_ERROR_ONE_TIME);
307                         return EXIT_FAILURE;
308                     }
309 
310                     /* Remember that a /T switch has been encountered */
311                     fTimerFlags |= 2;
312 
313                     /* Go to the next (timer) value */
314                     continue;
315                 }
316             }
317 
318             /* This flag is used to ignore any keyboard keys but Ctrl-C */
319             if (_wcsicmp(&argv[index][1], L"NOBREAK") == 0)
320             {
321                 bDisableInput = TRUE;
322 
323                 /* Go to next value */
324                 continue;
325             }
326         }
327 
328         /* The timer value can also be specified without the /T switch */
329 
330         /* Only one timer value is supported */
331         if (fTimerFlags & 1)
332         {
333             ConResPrintf(StdErr, IDS_ERROR_ONE_TIME);
334             return EXIT_FAILURE;
335         }
336 
337         timerValue = wcstol(argv[index], &pszNext, 10);
338         if (*pszNext)
339         {
340             ConResPrintf(StdErr, IDS_ERROR_OUT_OF_RANGE);
341             return EXIT_FAILURE;
342         }
343 
344         /* Remember that the timer value has been set */
345         fTimerFlags |= 1;
346     }
347 
348     /* A timer value is mandatory in order to continue */
349     if (!(fTimerFlags & 1))
350     {
351         ConResPrintf(StdErr, IDS_ERROR_NO_TIMER_VALUE);
352         return EXIT_FAILURE;
353     }
354 
355     /* Make sure the timer value is within range */
356     if ((timerValue < -1) || (timerValue > 99999))
357     {
358         ConResPrintf(StdErr, IDS_ERROR_OUT_OF_RANGE);
359         return EXIT_FAILURE;
360     }
361 
362     return InputWait(bDisableInput, timerValue);
363 }
364