1 files changed, 299 insertions, 65 deletions

diff --git a/libbb/lineedit.c b/libbb/lineedit.c
index 151208c1c..c8a0f37fe 100644
--- a/libbb/lineedit.c
+++ b/libbb/lineedit.c
@@ -258,8 +258,14 @@ static NOINLINE const char *get_homedir_or_NULL(void)
 # else
         home = getenv("HOME");
 # endif
-        if (home != NULL && home[0] != '\0')
+        if (home != NULL && home[0] != '\0') {
+# if ENABLE_PLATFORM_MINGW32
+                char *t = auto_string(xstrdup(home));
+                bs_to_slash(t);
+                home = t;
+# endif
                 return home;
+        }
 
         if (!got_user_strings)
                 get_user_strings();
@@ -413,7 +419,7 @@ int adjust_width_and_validate_wc(unsigned *width_adj, int wc);
 /* Put 'command_ps[cursor]', cursor++.
  * Advance cursor on screen. If we reached right margin, scroll text up
  * and remove terminal margin effect by printing 'next_char' */
-#define HACK_FOR_WRONG_WIDTH 1
+#define HACK_FOR_WRONG_WIDTH 1 && !ENABLE_PLATFORM_MINGW32
 static void put_cur_glyph_and_inc_cursor(void)
 {
         CHAR_T c = command_ps[cursor];
@@ -451,7 +457,7 @@ static void put_cur_glyph_and_inc_cursor(void)
                  * have automargin (IOW: it is moving cursor to next line
                  * by itself (which is wrong for VT-10x terminals)),
                  * this will break things: there will be one extra empty line */
-                puts("\r"); /* + implicit '\n' */
+                fputs("\r\n", stderr);
 #else
                 /* VT-10x terminals don't wrap cursor to next line when last char
                  * on the line is printed - cursor stays "over" this char.
@@ -476,6 +482,42 @@ static void put_cur_glyph_and_inc_cursor(void)
         }
 }
 
+#if ENABLE_PLATFORM_MINGW32
+static void inc_cursor(void)
+{
+        CHAR_T c = command_ps[cursor];
+        unsigned width = 0;
+        int ofs_to_right;
+
+        /* advance cursor */
+        cursor++;
+        if (unicode_status == UNICODE_ON) {
+                IF_UNICODE_WIDE_WCHARS(width = cmdedit_x;)
+                c = adjust_width_and_validate_wc(&cmdedit_x, c);
+                IF_UNICODE_WIDE_WCHARS(width = cmdedit_x - width;)
+        } else {
+                cmdedit_x++;
+        }
+
+        ofs_to_right = cmdedit_x - cmdedit_termw;
+        if (!ENABLE_UNICODE_WIDE_WCHARS || ofs_to_right <= 0) {
+                /* cursor remains on this line */
+                printf(ESC"[1C");
+        }
+
+        if (ofs_to_right >= 0) {
+                /* we go to the next line */
+                printf(ESC"[1B");
+                bb_putchar('\r');
+                cmdedit_y++;
+                if (!ENABLE_UNICODE_WIDE_WCHARS || ofs_to_right == 0) {
+                        width = 0;
+                }
+                cmdedit_x = width;
+        }
+}
+#endif
+
 /* Move to end of line (by printing all chars till the end) */
 static void put_till_end_and_adv_cursor(void)
 {
@@ -538,6 +580,7 @@ static void input_backward(unsigned num)
 
         if (cmdedit_x >= num) {
                 cmdedit_x -= num;
+#if !ENABLE_PLATFORM_MINGW32
                 if (num <= 4) {
                         /* This is longer by 5 bytes on x86.
                          * Also gets miscompiled for ARM users
@@ -550,6 +593,7 @@ static void input_backward(unsigned num)
                         } while (--num);
                         return;
                 }
+#endif
                 fprintf(stderr, ESC"[%uD", num);
                 return;
         }
@@ -688,7 +732,23 @@ static void input_backspace(void)
 static void input_forward(void)
 {
         if (cursor < command_len)
+#if !ENABLE_PLATFORM_MINGW32
                 put_cur_glyph_and_inc_cursor();
+#else
+        /*
+         * inc_cursor improves forward cursor movement appearance on
+         * win 7/8 console, but it's broken with unicode wide-glyphs,
+         * e.g. paste and move forward over: echo 开开心心过每一天
+         * so disable inc_cursor when unicode is active (which is only
+         * windows 10+, where inc_cursor is not needed anyway).
+         */
+        {
+                if (unicode_status == UNICODE_ON)
+                        put_cur_glyph_and_inc_cursor();
+                else
+                        inc_cursor();
+        }
+#endif
 }
 
 #if ENABLE_FEATURE_TAB_COMPLETION
@@ -709,25 +769,56 @@ static void free_tab_completion_data(void)
         }
 }
 
-static void add_match(char *matched)
+#if !ENABLE_PLATFORM_MINGW32
+# define add_match(m, s) add_match(m)
+#endif
+
+static void add_match(char *matched, int sensitive)
 {
+# if ENABLE_PLATFORM_MINGW32
+        size_t len;
+# endif
         unsigned char *p = (unsigned char*)matched;
         while (*p) {
                 /* ESC attack fix: drop any string with control chars */
                 if (*p < ' '
+# if !ENABLE_PLATFORM_MINGW32
                  || (!ENABLE_UNICODE_SUPPORT && *p >= 0x7f)
                  || (ENABLE_UNICODE_SUPPORT && *p == 0x7f)
+# else
+                /*
+                 * on Windows, *p > 0x7f is never control:
+                 * without unicode active: these are normal codepage chars.
+                 * with unicode active: these are UTF8 continuation bytes.
+                 */
+                 || *p == 0x7f
+# endif
                 ) {
                         free(matched);
                         return;
                 }
                 p++;
         }
+# if ENABLE_PLATFORM_MINGW32
+        /* The case-sensitivity flag is stored after NUL terminator */
+        len = strlen(matched);
+        matched = xrealloc(matched, len + 2);
+        matched[len + 1] = sensitive;
+# endif
         matches = xrealloc_vector(matches, 4, num_matches);
         matches[num_matches] = matched;
         num_matches++;
 }
 
+# if ENABLE_PLATFORM_MINGW32
+static int is_case_sensitive(const char *p)
+{
+        while (*p++)
+                ;
+        return *p;
+}
+# endif
+
 # if ENABLE_FEATURE_USERNAME_COMPLETION
 /* Replace "~user/..." with "/homedir/...".
  * The parameter is malloced, free it or return it
@@ -735,13 +826,16 @@ static void add_match(char *matched)
  */
 static char *username_path_completion(char *ud)
 {
+#  if !ENABLE_PLATFORM_MINGW32
         struct passwd *entry;
+#endif
         char *tilde_name = ud;
         const char *home = NULL;
 
         ud++; /* skip ~ */
         if (*ud == '/') {       /* "~/..." */
                 home = get_homedir_or_NULL();
+#  if !ENABLE_PLATFORM_MINGW32
         } else {
                 /* "~user/..." */
                 ud = strchr(ud, '/');
@@ -750,6 +844,7 @@ static char *username_path_completion(char *ud)
                 *ud = '/';            /* restore "~user/..." */
                 if (entry)
                         home = entry->pw_dir;
+#  endif
         }
         if (home) {
                 ud = concat_path_file(home, ud);
@@ -759,6 +854,7 @@ static char *username_path_completion(char *ud)
         return tilde_name;
 }
 
+#  if !ENABLE_PLATFORM_MINGW32
 /* ~use<tab> - find all users with this prefix.
  * Return the length of the prefix used for matching.
  */
@@ -774,13 +870,14 @@ static NOINLINE unsigned complete_username(const char *ud)
         while ((pw = getpwent()) != NULL) {
                 /* Null usernames should result in all users as possible completions. */
                 if (/* !ud[0] || */ is_prefixed_with(pw->pw_name, ud)) {
-                        add_match(xasprintf("~%s/", pw->pw_name));
+                        add_match(xasprintf("~%s/", pw->pw_name), TRUE);
                 }
         }
         endpwent(); /* don't keep password file open */
 
         return 1 + userlen;
 }
+#  endif
 # endif  /* FEATURE_USERNAME_COMPLETION */
 
 enum {
@@ -810,7 +907,7 @@ static unsigned path_parse(char ***p)
         tmp = (char*)pth;
         npth = 1; /* path component count */
         while (1) {
-                tmp = strchr(tmp, ':');
+                tmp = strchr(tmp, PATH_SEP);
                 if (!tmp)
                         break;
                 tmp++;
@@ -821,7 +918,7 @@ static unsigned path_parse(char ***p)
         res[0] = tmp = xstrdup(pth);
         npth = 1;
         while (1) {
-                tmp = strchr(tmp, ':');
+                tmp = strchr(tmp, PATH_SEP);
                 if (!tmp)
                         break;
                 *tmp++ = '\0'; /* ':' -> '\0' */
@@ -849,6 +946,17 @@ static NOINLINE unsigned complete_cmd_dir_file(const char *command, int type)
         path1[0] = (char*)".";
 
         basecmd = strrchr(command, '/');
+#if ENABLE_PLATFORM_MINGW32
+        if (!basecmd && has_dos_drive_prefix(command) && command[2] != '\0') {
+                char buffer[PATH_MAX];
+
+                /* path is of form c:path with no '/' */
+                if (get_drive_cwd(command, buffer, PATH_MAX)) {
+                        basecmd = command + 2;
+                        path1[0] = dirbuf = xstrdup(buffer);
+                }
+        } else
+#endif
         if (!basecmd) {
                 if (type == FIND_EXE_ONLY)
                         npaths = path_parse(&paths);
@@ -869,9 +977,13 @@ static NOINLINE unsigned complete_cmd_dir_file(const char *command, int type)
         if (type == FIND_EXE_ONLY && !dirbuf) {
 # if ENABLE_FEATURE_SH_STANDALONE && NUM_APPLETS != 1
                 const char *p = applet_names;
+#  if ENABLE_PLATFORM_MINGW32
+                const char *shpath = state->flags & WITH_PATH_LOOKUP ?
+                                                                state->path_lookup : NULL;
+#  endif
                 while (*p) {
-                        if (strncmp(basecmd, p, baselen) == 0)
-                                add_match(xstrdup(p));
+                        if (strncmp(basecmd, p, baselen) == 0 && prefer_applet(p, shpath))
+                                add_match(xstrdup(p), TRUE);
                         while (*p++ != '\0')
                                 continue;
                 }
@@ -884,7 +996,7 @@ static NOINLINE unsigned complete_cmd_dir_file(const char *command, int type)
                                 if (!b)
                                         break;
                                 if (strncmp(basecmd, b, baselen) == 0)
-                                        add_match(xstrdup(b));
+                                        add_match(xstrdup(b), TRUE);
                         }
                 }
 # endif
@@ -918,7 +1030,11 @@ static NOINLINE unsigned complete_cmd_dir_file(const char *command, int type)
                         if (!basecmd[0] && DOT_OR_DOTDOT(name_found))
                                 continue;
                         /* match? */
+# if ENABLE_PLATFORM_MINGW32
+                        if (strncasecmp(basecmd, name_found, baselen) != 0)
+# else
                         if (strncmp(basecmd, name_found, baselen) != 0)
+# endif
                                 continue; /* no */
 
                         found = concat_path_file(lpath, name_found);
@@ -928,6 +1044,16 @@ static NOINLINE unsigned complete_cmd_dir_file(const char *command, int type)
                         if (stat(found, &st) && lstat(found, &st))
                                 goto cont; /* hmm, remove in progress? */
 
+# if ENABLE_PLATFORM_MINGW32
+#  if ENABLE_ASH_GLOB_OPTIONS
+                        if (state->sh_accept_glob && !state->sh_accept_glob(found))
+                                goto cont;
+#  endif
+                        if (type == FIND_EXE_ONLY && S_ISREG(st.st_mode) &&
+                                        !(st.st_mode & S_IXUSR))
+                                goto cont;
+# endif
+
                         /* Save only name */
                         len = strlen(name_found);
                         found = xrealloc(found, len + 2); /* +2: for slash and NUL */
@@ -946,7 +1072,7 @@ static NOINLINE unsigned complete_cmd_dir_file(const char *command, int type)
                                         goto cont;
                         }
                         /* add it to the list */
-                        add_match(found);
+                        add_match(found, FALSE);
                         continue;
  cont:
                         free(found);
@@ -1011,7 +1137,13 @@ static NOINLINE int build_match_prefix(char *match_buf)
 
         /* Mark every \c as "quoted c" */
         for (i = 0; int_buf[i]; i++) {
+#if ENABLE_PLATFORM_MINGW32
+                /* Trailing backslash is effectively removed which confuses
+                 * the code to display case-preserved filenames. */
+                if (int_buf[i] == '\\' && int_buf[i+1] != '\0') {
+#else
                 if (int_buf[i] == '\\') {
+#endif
                         remove_chunk(int_buf, i, i + 1);
                         int_buf[i] |= QUOT;
                 }
@@ -1170,9 +1302,10 @@ static void showfiles(void)
                         );
                 }
                 if (ENABLE_UNICODE_SUPPORT)
-                        puts(printable_string(matches[n]));
+                        fputs(printable_string(matches[n]), stderr);
                 else
-                        puts(matches[n]);
+                        fputs(matches[n], stderr);
+                bb_putchar_stderr('\n');
         }
 }
 
@@ -1212,6 +1345,25 @@ static NOINLINE void input_tab(smallint *lastWasTab)
         size_t len_found;
         /* Length of string used for matching */
         unsigned match_pfx_len = match_pfx_len;
+# if ENABLE_PLATFORM_MINGW32
+        int chosen_index = 0;
+        int chosen_sens = FALSE;
+#  if !ENABLE_UNICODE_SUPPORT
+        /*
+         * FIXME: the next three vars are unused with ENABLE_UNICODE_SUPPORT
+         * because the mingw code which uses them to update a tab-completion
+         * prefix to the correct case (e.g. ~/desk<tab> to ~/Desktop/) is
+         * not compiled, and so e.g. ~/desk<tab> completes to ~/desktop/ .
+         */
+        unsigned orig_pfx_len;
+        char *target;
+        const char *source;
+#  endif
+#  define first_match 0
+# else
+#  define chosen_index 0
+#  define first_match 1
+# endif
         int find_type;
 # if ENABLE_UNICODE_SUPPORT
         /* cursor pos in command converted to multibyte form */
@@ -1259,7 +1411,7 @@ static NOINLINE void input_tab(smallint *lastWasTab)
         /* Free up any memory already allocated */
         free_tab_completion_data();
 
-# if ENABLE_FEATURE_USERNAME_COMPLETION
+# if ENABLE_FEATURE_USERNAME_COMPLETION && !ENABLE_PLATFORM_MINGW32
         /* If the word starts with ~ and there is no slash in the word,
          * then try completing this word as a username. */
         if (state->flags & USERNAME_COMPLETION)
@@ -1276,6 +1428,9 @@ static NOINLINE void input_tab(smallint *lastWasTab)
         {
                 const char *e = match_buf + strlen(match_buf);
                 const char *s = e - match_pfx_len;
+# if ENABLE_PLATFORM_MINGW32 && !ENABLE_UNICODE_SUPPORT
+                orig_pfx_len = match_pfx_len;
+# endif
                 while (s < e)
                         if (is_special_char(*s++))
                                 match_pfx_len++;
@@ -1306,10 +1461,29 @@ static NOINLINE void input_tab(smallint *lastWasTab)
                 if (!matches)
                         goto ret; /* no matches at all */
                 /* Find common prefix */
-                chosen_match = xstrdup(matches[0]);
+# if ENABLE_PLATFORM_MINGW32
+                /* Any comparison involving a filename must be case-insensitive.
+                 * The chosen match should be case-sensitive, if possible */
+                for (unsigned i = 0; i < num_matches; ++i) {
+                        if (is_case_sensitive(matches[i])) {
+                                chosen_index = i;
+                                chosen_sens = TRUE;
+                                break;
+                        }
+                }
+# endif
+                chosen_match = xstrdup(matches[chosen_index]);
                 for (cp = chosen_match; *cp; cp++) {
                         unsigned n;
-                        for (n = 1; n < num_matches; n++) {
+                        for (n = first_match; n < num_matches; n++) {
+# if ENABLE_PLATFORM_MINGW32
+                                if (!is_case_sensitive(matches[n]) || !chosen_sens) {
+                                        if (tolower(matches[n][cp - chosen_match]) !=
+                                                        tolower(*cp)) {
+                                                goto stop;
+                                        }
+                                } else
+# endif
                                 if (matches[n][cp - chosen_match] != *cp) {
                                         goto stop;
                                 }
@@ -1346,7 +1520,21 @@ static NOINLINE void input_tab(smallint *lastWasTab)
                 /* save tail */
                 strcpy(match_buf, &command_ps[cursor]);
                 /* add match and tail */
+#  if ENABLE_PLATFORM_MINGW32
+                if (match_pfx_len == orig_pfx_len) {
+                        /* replace match prefix to allow for altered case */
+                        target = &command_ps[cursor-match_pfx_len];
+                        source = chosen_match;
+                }
+                else {
+                        /* only replace tail of match if special characters are quoted */
+                        target = &command_ps[cursor];
+                        source = chosen_match + match_pfx_len;
+                }
+                strcpy(stpcpy(target, source), match_buf);
+#  else
                 sprintf(&command_ps[cursor], "%s%s", chosen_match + match_pfx_len, match_buf);
+#  endif
                 command_len = strlen(command_ps);
                 /* new pos */
                 pos = cursor + len_found - match_pfx_len;
@@ -1382,7 +1570,6 @@ static NOINLINE void input_tab(smallint *lastWasTab)
         free(chosen_match);
         free(match_buf);
 }
-
 #endif  /* FEATURE_TAB_COMPLETION */
 
 
@@ -1402,11 +1589,15 @@ line_input_t* FAST_FUNC new_line_input_t(int flags)
 
 unsigned FAST_FUNC size_from_HISTFILESIZE(const char *hp)
 {
+# if ENABLE_PLATFORM_MINGW32 && DEFAULT_HISTORY > 0 && DEFAULT_HISTORY <= MAX_HISTORY
+        int size = DEFAULT_HISTORY;
+# else
         int size = MAX_HISTORY;
+# endif
         if (hp) {
                 size = atoi(hp);
-                if (size <= 0)
-                        return 1;
+                if (size < 0)
+                        return 0;
                 if (size > MAX_HISTORY)
                         return MAX_HISTORY;
         }
@@ -1500,18 +1691,21 @@ static void load_history(line_input_t *st_parm)
         /* NB: do not trash old history if file can't be opened */
 
         fp = fopen_for_read(st_parm->hist_file);
-        if (fp) {
-                /* clean up old history */
-                for (idx = st_parm->cnt_history; idx > 0;) {
-                        idx--;
-                        free(st_parm->history[idx]);
-                        st_parm->history[idx] = NULL;
-                }
+        if (!fp)
+                return;
+
+        /* clean up old history */
+        for (idx = st_parm->cnt_history; idx > 0;) {
+                idx--;
+                free(st_parm->history[idx]);
+                st_parm->history[idx] = NULL;
+        }
 
-                /* fill temp_h[], retaining only last MAX_HISTORY lines */
-                memset(temp_h, 0, sizeof(temp_h));
-                idx = 0;
-                st_parm->cnt_history_in_file = 0;
+        /* fill temp_h[], retaining only last max_history lines */
+        memset(temp_h, 0, sizeof(temp_h));
+        idx = 0;
+        st_parm->cnt_history_in_file = 0;
+        if (st_parm->max_history != 0) {
                 while ((line = xmalloc_fgetline(fp)) != NULL) {
                         if (line[0] == '\0') {
                                 free(line);
@@ -1524,34 +1718,34 @@ static void load_history(line_input_t *st_parm)
                         if (idx == st_parm->max_history)
                                 idx = 0;
                 }
-                fclose(fp);
-
-                /* find first non-NULL temp_h[], if any */
-                if (st_parm->cnt_history_in_file) {
-                        while (temp_h[idx] == NULL) {
-                                idx++;
-                                if (idx == st_parm->max_history)
-                                        idx = 0;
-                        }
-                }
+        }
+        fclose(fp);
 
-                /* copy temp_h[] to st_parm->history[] */
-                for (i = 0; i < st_parm->max_history;) {
-                        line = temp_h[idx];
-                        if (!line)
-                                break;
+        /* find first non-NULL temp_h[], if any */
+        if (st_parm->cnt_history_in_file != 0) {
+                while (temp_h[idx] == NULL) {
                         idx++;
                         if (idx == st_parm->max_history)
                                 idx = 0;
-                        line_len = strlen(line);
-                        if (line_len >= MAX_LINELEN)
-                                line[MAX_LINELEN-1] = '\0';
-                        st_parm->history[i++] = line;
                 }
-                st_parm->cnt_history = i;
-                if (ENABLE_FEATURE_EDITING_SAVE_ON_EXIT)
-                        st_parm->cnt_history_in_file = i;
         }
+
+        /* copy temp_h[] to st_parm->history[] */
+        for (i = 0; i < st_parm->max_history;) {
+                line = temp_h[idx];
+                if (!line)
+                        break;
+                idx++;
+                if (idx == st_parm->max_history)
+                        idx = 0;
+                line_len = strlen(line);
+                if (line_len >= MAX_LINELEN)
+                        line[MAX_LINELEN-1] = '\0';
+                st_parm->history[i++] = line;
+        }
+        st_parm->cnt_history = i;
+        if (ENABLE_FEATURE_EDITING_SAVE_ON_EXIT)
+                st_parm->cnt_history_in_file = i;
 }
 
 #  if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
@@ -1559,17 +1753,27 @@ void FAST_FUNC save_history(line_input_t *st)
 {
         FILE *fp;
 
-        if (!st || !st->hist_file)
+        /* bash compat: HISTFILE="" disables history saving */
+        if (!st || !st->hist_file || !state->hist_file[0])
                 return;
         if (st->cnt_history <= st->cnt_history_in_file)
-                return;
+                return; /* no new entries were added */
+        /* note: if st->max_history is 0, we do not abort: we truncate the history to 0 lines */
 
-        fp = fopen(st->hist_file, "a");
+        fp = fopen(st->hist_file, (st->max_history == 0 ? "w" : "a"));
         if (fp) {
                 int i, fd;
                 char *new_name;
                 line_input_t *st_temp;
 
+                /* max_history==0 needs special-casing in general code,
+                 * just handle it in a simpler way: */
+                if (st->max_history == 0) {
+                        /* fopen("w") already truncated it */
+                        fclose(fp);
+                        return;
+                }
+
                 for (i = st->cnt_history_in_file; i < st->cnt_history; i++)
                         fprintf(fp, "%s\n", st->history[i]);
                 fclose(fp);
@@ -1579,6 +1783,8 @@ void FAST_FUNC save_history(line_input_t *st)
                 st_temp = new_line_input_t(st->flags);
                 st_temp->hist_file = st->hist_file;
                 st_temp->max_history = st->max_history;
+                /* load no more than max_history last lines */
+                /* (in unlikely case that file disappeared, st_temp gets empty history) */
                 load_history(st_temp);
 
                 /* write out temp file and replace hist_file atomically */
@@ -1602,13 +1808,13 @@ static void save_history(char *str)
         int fd;
         int len, len2;
 
-        if (!state->hist_file)
+        /* bash compat: HISTFILE="" disables history saving */
+        if (!state->hist_file || !state->hist_file[0])
                 return;
 
         fd = open(state->hist_file, O_WRONLY | O_CREAT | O_APPEND, 0600);
         if (fd < 0)
                 return;
-        xlseek(fd, 0, SEEK_END); /* paranoia */
         len = strlen(str);
         str[len] = '\n'; /* we (try to) do atomic write */
         len2 = full_write(fd, str, len + 1);
@@ -1663,13 +1869,10 @@ static void remember_in_history(char *str)
         if (str[0] == '\0')
                 return;
         i = state->cnt_history;
-        /* Don't save dupes */
-        if (i && strcmp(state->history[i-1], str) == 0)
+        /* Don't save dups */
+        if (i != 0 && strcmp(state->history[i-1], str) == 0)
                 return;
 
-        free(state->history[state->max_history]); /* redundant, paranoia */
-        state->history[state->max_history] = NULL; /* redundant, paranoia */
-
         /* If history[] is full, remove the oldest command */
         /* we need to keep history[state->max_history] empty, hence >=, not > */
         if (i >= state->max_history) {
@@ -1682,7 +1885,7 @@ static void remember_in_history(char *str)
                         state->cnt_history_in_file--;
 # endif
         }
-        /* i <= state->max_history-1 */
+        /* i < state->max_history */
         state->history[i++] = xstrdup(str);
         /* i <= state->max_history */
         state->cur_history = i;
@@ -2053,7 +2256,11 @@ static void parse_and_put_prompt(const char *prmt_ptr)
                                                         char *after_home_user;
 
                                                         /* /home/user[/something] -> ~[/something] */
+#if !ENABLE_PLATFORM_MINGW32
                                                         after_home_user = is_prefixed_with(cwd_buf, home);
+#else
+                                                        after_home_user = is_prefixed_with_case(cwd_buf, home);
+#endif
                                                         if (after_home_user
                                                          && (*after_home_user == '/' || *after_home_user == '\0')
                                                         ) {
@@ -2194,7 +2401,6 @@ static int lineedit_read_key(char *read_key_buffer, int timeout)
                                 errno = EINTR;
                                 return -1;
                         }
-//FIXME: still races here with signals, but small window to poll() inside read_key
                         IF_FEATURE_EDITING_WINCH(S.ok_to_redraw = 1;)
                         /* errno = 0; - read_key does this itself */
                         ic = read_key(STDIN_FILENO, read_key_buffer, timeout);
@@ -2484,7 +2690,11 @@ int FAST_FUNC read_line_input(line_input_t *st, const char *prompt, char *comman
         n = get_termios_and_make_raw(STDIN_FILENO, &new_settings, &initial_settings, 0
                 | TERMIOS_CLEAR_ISIG /* turn off INTR (ctrl-C), QUIT, SUSP */
         );
+#if !ENABLE_PLATFORM_MINGW32
         if (n != 0 || (initial_settings.c_lflag & (ECHO|ICANON)) == ICANON) {
+#else
+        if (n != 0 || !isatty(0)) {
+#endif
                 /* Happens when e.g. stty -echo was run before.
                  * But if ICANON is not set, we don't come here.
                  * (example: interactive python ^Z-backgrounded,
@@ -2494,8 +2704,12 @@ int FAST_FUNC read_line_input(line_input_t *st, const char *prompt, char *comman
                 fflush_all();
                 if (fgets(command, maxsize, stdin) == NULL)
                         len = -1; /* EOF or error */
-                else
+                else {
                         len = strlen(command);
+#if ENABLE_PLATFORM_MINGW32
+                        len = remove_cr(command, len);
+#endif
+                }
                 DEINIT_S();
                 return len;
         }
@@ -2577,6 +2791,11 @@ int FAST_FUNC read_line_input(line_input_t *st, const char *prompt, char *comman
                 }
 #endif
                 ic = ic_raw = lineedit_read_key(read_key_buffer, timeout);
+#if ENABLE_PLATFORM_MINGW32
+                /* scroll to cursor position on any keypress */
+                if (isatty(fileno(stdin)) && isatty(fileno(stdout)))
+                        move_cursor_row(0);
+#endif
 
 #if ENABLE_FEATURE_REVERSE_SEARCH
  again:
@@ -2638,6 +2857,17 @@ int FAST_FUNC read_line_input(line_input_t *st, const char *prompt, char *comman
                         input_tab(&lastWasTab);
                         break;
 #endif
+#if ENABLE_PLATFORM_MINGW32
+                case CTRL('Z'):
+                        command_ps[command_len] = '\0';
+                #if ENABLE_UNICODE_SUPPORT
+                        bs_to_slash_u(command_ps);
+                #else
+                        bs_to_slash(command_ps);
+                #endif
+                        redraw(cmdedit_y, 0);
+                        break;
+#endif
                 case CTRL('K'):
                         /* Control-k -- clear to end of line */
                         command_ps[cursor] = BB_NUL;
@@ -2892,6 +3122,10 @@ int FAST_FUNC read_line_input(line_input_t *st, const char *prompt, char *comman
                          && ic_raw == initial_settings.c_cc[VINTR]
                         ) {
                                 /* Ctrl-C (usually) - stop gathering input */
+#if ENABLE_PLATFORM_MINGW32
+                                if (state->flags & IGNORE_CTRL_C)
+                                        break;
+#endif
                                 command_len = 0;
                                 break_out = -1; /* "do not append '\n'" */
                                 break;