win32: UTF8 input: avoid timeout when delivering UTF8 bytes

When windows_read_key - which is the sole consumer of
readConsoleInput_utf8 - is called with a timeout value, it uses
WaitForSingleObject to test whether the console has pending input.

Previously, readConsoleInput_utf8 consumed the input record before
it delivered the UTF8 bytes which are generated from it.

It's not an issue with ASCII-7 input - because indeed there are no
buffered bytes once it's delivered, and, except for console bugs
(when only key-up record exists) also not an issue with 2 or 3 bytes
UTF8 codepoints - because these are generated from a single wchar_t
input record on key-down, and the key-up event is not yet dequeued
while delivering the key-down UTF8 bytes.

But with a surrogate pair, which consumes two wchar_t records to
realize the UTF8 sequence, we previously consumed the records
up to and including the key-up event of the 2nd surrogate half.

This could result in a timeout if there are no further records at
the queue - eventhough some UTF8 bytes are still buffered/pending.

Such timeout can result in the shell aborting - windows_read_key
returns -1, which is later interpreted as EOF of the shell input,
and quits the shell.

Now readConsoleInput_utf8 dequeues an input record only once the
last byte which was generated from this record is delivered,
which we do using PeekConsoleInputW instead of ReadConsoleInputW.

This avoid a timeout as long as there are input bytes to deliver.

1 files changed, 14 insertions, 6 deletions

diff --git a/win32/winansi.c b/win32/winansi.c
index f823d14be..d85b6de23 100644
--- a/win32/winansi.c
+++ b/win32/winansi.c
@@ -1223,7 +1223,7 @@ static int toutf8(DWORD cp, unsigned char *buf) {
 
 // peek into the console input queue and try to find a key-up event of
 // a surrugate-2nd-half, at which case eat the console events up to this
-// one, and combine the pair values into *ph1
+// one (excluding), and combine the pair values into *ph1
 static void maybeEatUpto2ndHalfUp(HANDLE h, DWORD *ph1)
 {
         // Peek into the queue arbitrary 16 records deep
@@ -1236,7 +1236,8 @@ static void maybeEatUpto2ndHalfUp(HANDLE h, DWORD *ph1)
 
         // we're conservative, and abort the search on anything which
         // seems out of place, like non-key event, non-2nd-half, etc.
-        for (i = 0; i < got; ++i) {
+        // search from 1 because i==0 is still the 1st half down record.
+        for (i = 1; i < got; ++i) {
                 DWORD h2;
                 int is2nd, isdown;
 
@@ -1255,7 +1256,7 @@ static void maybeEatUpto2ndHalfUp(HANDLE h, DWORD *ph1)
                         return;
 
                 // got 2nd-half-up. eat the events up to this, combine the values
-                ReadConsoleInputW(h, r, i + 1, &got);
+                ReadConsoleInputW(h, r, i, &got);
                 *ph1 = 0x10000 | ((*ph1 & ~0xD800) << 10) | (h2 & ~0xDC00);
                 return;
         }
@@ -1313,10 +1314,15 @@ BOOL readConsoleInput_utf8(HANDLE h, INPUT_RECORD *r, DWORD len, DWORD *got)
         if (u8pos == u8len) {
                 DWORD codepoint;
 
-                if (!ReadConsoleInputW(h, r, 1, got))
+                // peek rather than read to keep the last processed record at
+                // the console queue until we deliver all of its products, so
+                // that WaitForSingleObject(handle) shows there's data ready.
+                if (!PeekConsoleInputW(h, r, 1, got))
                         return FALSE;
-                if (*got == 0 || r->EventType != KEY_EVENT)
+                if (*got == 0)
                         return TRUE;
+                if (r->EventType != KEY_EVENT)
+                        return ReadConsoleInput(h, r, 1, got);
 
                 srec = *r;
                 codepoint = srec.Event.KeyEvent.uChar.UnicodeChar;
@@ -1334,7 +1340,7 @@ BOOL readConsoleInput_utf8(HANDLE h, INPUT_RECORD *r, DWORD len, DWORD *got)
                 }
 
                 // if it's a 1st (high) surrogate pair half, try to eat upto and
-                // including the 2nd (low) half, and combine them into codepoint.
+                // excluding the 2nd (low) half, and combine them into codepoint.
                 if (codepoint >= 0xD800 && codepoint <= 0xDBFF)
                         maybeEatUpto2ndHalfUp(h, &codepoint);
 
@@ -1344,6 +1350,8 @@ BOOL readConsoleInput_utf8(HANDLE h, INPUT_RECORD *r, DWORD len, DWORD *got)
 
         *r = srec;
         r->Event.KeyEvent.uChar.AsciiChar = (char)u8buf[u8pos++];
+        if (u8pos == u8len)  // consume the record which generated this buffer
+                ReadConsoleInputW(h, &srec, 1, got);
         *got = 1;
         return TRUE;
 }