1 files changed, 96 insertions, 9 deletions

diff --git a/shell/shell_common.c b/shell/shell_common.c
index e5c2cefb3..657f0df8f 100644
--- a/shell/shell_common.c
+++ b/shell/shell_common.c
@@ -55,14 +55,16 @@ const char* FAST_FUNC
 shell_builtin_read(struct builtin_read_params *params)
 {
         struct pollfd pfd[1];
-#define fd (pfd[0].fd) /* -u FD */
+#define fd (pfd->fd) /* -u FD */
         unsigned err;
         unsigned end_ms; /* -t TIMEOUT */
         int nchars; /* -n NUM */
         char **pp;
         char *buffer;
         char delim;
+#if !ENABLE_PLATFORM_MINGW32
         struct termios tty, old_tty;
+#endif
         const char *retval;
         int bufpos; /* need to be able to hold -1 */
         int startword;
@@ -142,7 +144,7 @@ shell_builtin_read(struct builtin_read_params *params)
                  * bash seems to ignore -p PROMPT for this use case.
                  */
                 int r;
-                pfd[0].events = POLLIN;
+                pfd->events = POLLIN;
                 r = poll(pfd, 1, /*timeout:*/ 0);
                 /* Return 0 only if poll returns 1 ("one fd ready"), else return 1: */
                 return (const char *)(uintptr_t)(r <= 0);
@@ -158,6 +160,7 @@ shell_builtin_read(struct builtin_read_params *params)
                 ifs = defifs;
 
         read_flags = params->read_flags;
+#if !ENABLE_PLATFORM_MINGW32
         if (nchars || (read_flags & BUILTIN_READ_SILENT)) {
                 tcgetattr(fd, &tty);
                 old_tty = tty;
@@ -180,6 +183,7 @@ shell_builtin_read(struct builtin_read_params *params)
                  * Ignoring, it's harmless. */
                 tcsetattr(fd, TCSANOW, &tty);
         }
+#endif
 
         retval = (const char *)(uintptr_t)0;
         startword = 1;
@@ -196,6 +200,7 @@ shell_builtin_read(struct builtin_read_params *params)
                 if ((bufpos & 0xff) == 0)
                         buffer = xrealloc(buffer, bufpos + 0x101);
 
+ IF_PLATFORM_MINGW32(loop:)
                 timeout = -1;
                 if (params->opt_t) {
                         timeout = end_ms - (unsigned)monotonic_ms();
@@ -204,8 +209,8 @@ shell_builtin_read(struct builtin_read_params *params)
                          * 32-bit unix time wrapped (year 2038+).
                          */
                         if (timeout <= 0) { /* already late? */
-                                retval = (const char *)(uintptr_t)1;
-                                goto ret;
+                                retval = (const char *)(uintptr_t)2;
+                                break;
                         }
                 }
 
@@ -214,14 +219,61 @@ shell_builtin_read(struct builtin_read_params *params)
                  * regardless of SA_RESTART-ness of that signal!
                  */
                 errno = 0;
-                pfd[0].events = POLLIN;
-//TODO race with a signal arriving just before the poll!
-                if (poll(pfd, 1, timeout) <= 0) {
-                        /* timed out, or EINTR */
+                pfd->events = POLLIN;
+
+#if ENABLE_PLATFORM_MINGW32
+                /* Don't poll if timeout is -1, it hurts performance.  The
+                 * caution above about interrupts isn't relevant on Windows
+                 * where Ctrl-C causes an event, not a signal.
+                 */
+                if (timeout >= 0)
+#endif
+                /* test bb_got_signal, then poll(), atomically wrt signals */
+                if (check_got_signal_and_poll(pfd, timeout) <= 0) {
+                        /* timed out, or some error */
                         err = errno;
+                        if (!err) { /* timed out */
+                                retval = (const char *)(uintptr_t)2;
+                                break;
+                        }
                         retval = (const char *)(uintptr_t)1;
                         goto ret;
                 }
+#if ENABLE_PLATFORM_MINGW32
+                if (isatty(fd)) {
+                        int64_t key;
+
+                        key = windows_read_key(fd, NULL, timeout);
+                        if (key == 0x03) {
+                                /* ^C pressed */
+                                retval = (const char *)(uintptr_t)3;
+                                goto ret;
+                        }
+                        else if (key == -1) {
+                                /* timeout */
+                                retval = (const char *)(uintptr_t)2;
+                                break;
+                        } else if (key == 0x1a && bufpos == 0) {
+                                /* ^Z at start of buffer */
+                                retval = (const char *)(uintptr_t)1;
+                                break;
+                        } else if (key == '\b') {
+                                if (bufpos > 0) {
+                                        --bufpos;
+                                        ++nchars;
+                                        if (!(read_flags & BUILTIN_READ_SILENT)) {
+                                                console_write("\b \b", 3);
+                                        }
+                                }
+                                goto loop;
+                        }
+                        buffer[bufpos] = key == '\r' ? '\n' : key;
+                        if (!(read_flags & BUILTIN_READ_SILENT)) {
+                                /* echo input if not in silent mode */
+                                console_write(buffer + bufpos, 1);
+                        }
+                } else
+#endif
                 if (read(fd, &buffer[bufpos], 1) != 1) {
                         err = errno;
                         retval = (const char *)(uintptr_t)1;
@@ -229,11 +281,37 @@ shell_builtin_read(struct builtin_read_params *params)
                 }
 
                 c = buffer[bufpos];
+#if ENABLE_PLATFORM_MINGW32
+                if (c == '\n') {
+                        if (backslash == 2 || (bufpos > 0 && buffer[bufpos - 1] == '\r')) {
+                                /* We saw either:
+                                 * - BS CR LF: remove CR, fall through to ignore escaped LF
+                                 *   and exit BS context.
+                                 * - CR LF not in BS context: replace CR with LF */
+                                buffer[--bufpos] = c;
+                                nchars += 1 + (backslash == 2);
+                        }
+                } else if (backslash == 2) {
+                        /* We saw BS CR ??, keep escaped CR, exit BS context,
+                         * process ?? */
+                        backslash = 0;
+                }
+#endif
                 if (!(read_flags & BUILTIN_READ_RAW)) {
                         if (backslash) {
+#if ENABLE_PLATFORM_MINGW32
+                                if (c == '\r') {
+                                        /* We have BS CR, keep CR for now, might see LF next */
+                                        backslash = 2;
+                                        goto put;
+                                }
+#endif
                                 backslash = 0;
                                 if (c != '\n')
                                         goto put;
+#if ENABLE_PLATFORM_MINGW32
+                                ++nchars;
+#endif
                                 continue;
                         }
                         if (c == '\\') {
@@ -274,7 +352,7 @@ shell_builtin_read(struct builtin_read_params *params)
                 }
  put:
                 bufpos++;
-        } while (--nchars);
+        } while (IF_PLATFORM_MINGW32(backslash ||) --nchars);
 
         if (argv[0]) {
                 /* Remove trailing space $IFS chars */
@@ -329,8 +407,10 @@ shell_builtin_read(struct builtin_read_params *params)
 
  ret:
         free(buffer);
+#if !ENABLE_PLATFORM_MINGW32
         if (read_flags & BUILTIN_READ_SILENT)
                 tcsetattr(fd, TCSANOW, &old_tty);
+#endif
 
         errno = err;
         return retval;
@@ -339,6 +419,7 @@ shell_builtin_read(struct builtin_read_params *params)
 
 /* ulimit builtin */
 
+#if !ENABLE_PLATFORM_MINGW32
 struct limits {
         uint8_t cmd;            /* RLIMIT_xxx fit into it */
         uint8_t factor_shift;   /* shift by to get rlim_{cur,max} values */
@@ -707,3 +788,9 @@ shell_builtin_ulimit(char **argv)
 
         return EXIT_SUCCESS;
 }
+#else
+int FAST_FUNC shell_builtin_ulimit(char **argv UNUSED_PARAM)
+{
+        return 1;
+}
+#endif