7 files changed, 1128 insertions, 86 deletions

diff --git a/include/.gitignore b/include/.gitignore
index 13a96e018..91575ed3f 100644
--- a/include/.gitignore
+++ b/include/.gitignore
@@ -3,6 +3,7 @@
 /applets.h
 /applet_tables.h
 /autoconf.h
+/BB_VER.h
 /bbconfigopts_bz2.h
 /bbconfigopts.h
 /embedded_scripts.h
diff --git a/include/bb_archive.h b/include/bb_archive.h
index e0ef8fc4e..3422c9656 100644
--- a/include/bb_archive.h
+++ b/include/bb_archive.h
@@ -2,6 +2,16 @@
 #ifndef UNARCHIVE_H
 #define UNARCHIVE_H 1
 
+#if !defined(BB_ARCHIVE_PUBLIC) && ENABLE_PLATFORM_MINGW32
+/* treat mingw as a non-MMU platform */
+#undef BB_MMU
+#undef USE_FOR_NOMMU
+#undef USE_FOR_MMU
+#define BB_MMU 0
+#define USE_FOR_NOMMU(...) __VA_ARGS__
+#define USE_FOR_MMU(...)
+#endif
+
 PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
 
 enum {
@@ -277,7 +287,11 @@ enum {
         BBUNPK_SEAMLESS_MAGIC = (1 << 31) * ENABLE_ZCAT * SEAMLESS_COMPRESSION,
 };
 
+#if !ENABLE_PLATFORM_MINGW32
 void check_errors_in_children(int signo);
+#else
+#define check_errors_in_children(s) ((void)0)
+#endif
 #if BB_MMU
 void fork_transformer(int fd,
         int signature_skipped,
diff --git a/include/libbb.h b/include/libbb.h
index 4d6193795..60037ed3d 100644
--- a/include/libbb.h
+++ b/include/libbb.h
@@ -10,6 +10,12 @@
 #ifndef LIBBB_H
 #define LIBBB_H 1
 
+#if ENABLE_PLATFORM_MINGW32
+/* We have our own nanosleep(), clock_gettime() and clock_settime(). */
+/* Skip the Windows include file that declares them. */
+# define WIN_PTHREADS_TIME_H
+#endif
+
 #include "platform.h"
 
 #include <ctype.h>
@@ -143,6 +149,9 @@
 # include <arpa/inet.h>
 #elif defined __APPLE__
 # include <netinet/in.h>
+#elif ENABLE_PLATFORM_MINGW32
+# include <winsock2.h>
+# include <ws2tcpip.h>
 #else
 # include <arpa/inet.h>
 //This breaks on bionic:
@@ -182,7 +191,9 @@
 
 /* Some libc's forget to declare these, do it ourself */
 
+#if !ENABLE_PLATFORM_MINGW32
 extern char **environ;
+#endif
 /* klogctl is in libc's klog.h, but we cheat and not #include that */
 int klogctl(int type, char *b, int len);
 #ifndef PATH_MAX
@@ -192,6 +203,13 @@ int klogctl(int type, char *b, int len);
 # define BUFSIZ 4096
 #endif
 
+#if ENABLE_PLATFORM_MINGW32
+# include "mingw.h"
+# define MINGW_SPECIAL(a) mingw_ ## a
+#else
+# define MINGW_SPECIAL(a) a
+#endif
+
 #if __GNUC_PREREQ(5,0)
 /* Since musl is apparently unable to get it right and would use
  * a function call to a single-instruction function of "bswap %eax",
@@ -263,6 +281,26 @@ PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
 # endif
 #endif
 
+#if ENABLE_FEATURE_TLS_SCHANNEL || ENABLE_FEATURE_USE_CNG_API
+# define SECURITY_WIN32
+# include <windows.h>
+# include <security.h>
+#endif
+
+#if ENABLE_FEATURE_USE_CNG_API
+# include <bcrypt.h>
+
+// these work on Windows >= 10
+# define BCRYPT_HMAC_SHA1_ALG_HANDLE   ((BCRYPT_ALG_HANDLE) 0x000000a1)
+# define BCRYPT_HMAC_SHA256_ALG_HANDLE ((BCRYPT_ALG_HANDLE) 0x000000b1)
+# define sha1_begin_hmac BCRYPT_HMAC_SHA1_ALG_HANDLE
+# define sha256_begin_hmac BCRYPT_HMAC_SHA256_ALG_HANDLE
+#else
+# define sha1_begin_hmac sha1_begin
+# define sha256_begin_hmac sha256_begin
+# define hmac_uninit(...) ((void)0)
+#endif
+
 /* Tested to work correctly with all int types (IIRC :]) */
 #define MAXINT(T) (T)( \
         ((T)-1) > 0 \
@@ -276,6 +314,20 @@ PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
         : ((T)1 << (sizeof(T)*8-1)) \
         )
 
+// UCRT supports both "ll" and "I64", but gcc warns on "I64" with UCRT mingw
+#if ENABLE_PLATFORM_MINGW32 && !defined(_UCRT) && \
+        (!defined(__USE_MINGW_ANSI_STDIO) || !__USE_MINGW_ANSI_STDIO)
+#define LL_FMT "I64"
+#else
+#define LL_FMT "ll"
+#endif
+
+#if ENABLE_PLATFORM_MINGW32 && defined(_WIN64)
+#define PID_FMT LL_FMT
+#else
+#define PID_FMT
+#endif
+
 /* Large file support */
 /* Note that CONFIG_LFS=y forces bbox to be built with all common ops
  * (stat, lseek etc) mapped to "largefile" variants by libc.
@@ -301,7 +353,7 @@ typedef unsigned long long uoff_t;
 #  define XATOOFF(a) xatoull_range((a), 0, LLONG_MAX)
 #  define BB_STRTOOFF bb_strtoull
 #  define STRTOOFF strtoull
-#  define OFF_FMT "ll"
+#  define OFF_FMT LL_FMT
 # endif
 #else
 /* CONFIG_LFS is off */
@@ -570,13 +622,20 @@ char *bb_get_last_path_component_nostrip(const char *path) FAST_FUNC;
 const char *bb_basename(const char *name) FAST_FUNC;
 /* NB: can violate const-ness (similarly to strchr) */
 char *last_char_is(const char *s, int c) FAST_FUNC;
+char *last_char_is_dir_sep(const char *s) FAST_FUNC;
 const char* endofname(const char *name) FAST_FUNC;
 char *is_prefixed_with(const char *string, const char *key) FAST_FUNC;
 char *is_suffixed_with(const char *string, const char *key) FAST_FUNC;
 
+#if !ENABLE_PLATFORM_MINGW32
 int ndelay_on(int fd) FAST_FUNC;
 int ndelay_off(int fd) FAST_FUNC;
 void close_on_exec_on(int fd) FAST_FUNC;
+#else
+static inline int ndelay_on(int fd UNUSED_PARAM) { return 0; }
+static inline int ndelay_off(int fd UNUSED_PARAM) { return 0; }
+static inline void close_on_exec_on(int fd UNUSED_PARAM) { return; }
+#endif
 void xdup2(int, int) FAST_FUNC;
 void xmove_fd(int, int) FAST_FUNC;
 
@@ -610,20 +669,37 @@ enum {
          * Dance around with long long to guard against that...
          */
         BB_FATAL_SIGS = (int)(0
+#ifdef SIGHUP
                 + (1LL << SIGHUP)
+#endif
                 + (1LL << SIGINT)
                 + (1LL << SIGTERM)
                 + (1LL << SIGPIPE)   // Write to pipe with no readers
+#ifdef SIGQUIT
                 + (1LL << SIGQUIT)   // Quit from keyboard
+#endif
                 + (1LL << SIGABRT)   // Abort signal from abort(3)
+#ifdef SIGALRM
                 + (1LL << SIGALRM)   // Timer signal from alarm(2)
+#endif
+#ifdef SIGVTALRM
                 + (1LL << SIGVTALRM) // Virtual alarm clock
+#endif
+#ifdef SIGXCPU
                 + (1LL << SIGXCPU)   // CPU time limit exceeded
+#endif
+#ifdef SIGXFSZ
                 + (1LL << SIGXFSZ)   // File size limit exceeded
+#endif
+#ifdef SIGUSR1
                 + (1LL << SIGUSR1)   // Yes kids, these are also fatal!
+#endif
+#ifdef SIGUSR1
                 + (1LL << SIGUSR2)
+#endif
                 + 0),
 };
+#if !ENABLE_PLATFORM_MINGW32
 void bb_signals(int sigs, void (*f)(int)) FAST_FUNC;
 /* Unlike signal() and bb_signals, sets handler with sigaction()
  * and in a way that while signal handler is run, no other signals
@@ -643,6 +719,10 @@ int sigaction_set(int sig, const struct sigaction *act) FAST_FUNC;
 int sigprocmask_allsigs(int how) FAST_FUNC;
 /* Return old set in the same set: */
 int sigprocmask2(int how, sigset_t *set) FAST_FUNC;
+#else
+#define bb_signals(s, f)
+#define kill_myself_with_sig(s)
+#endif
 /* Standard handler which just records signo */
 extern smallint bb_got_signal;
 void record_signo(int signo); /* not FAST_FUNC! */
@@ -726,7 +806,7 @@ void xsettimeofday(const struct timeval *tv) FAST_FUNC;
 int xsocket(int domain, int type, int protocol) FAST_FUNC;
 void xbind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen) FAST_FUNC;
 void xlisten(int s, int backlog) FAST_FUNC;
-void xconnect(int s, const struct sockaddr *s_addr, socklen_t addrlen) FAST_FUNC;
+void xconnect(int s, const struct sockaddr *saddr, socklen_t addrlen) FAST_FUNC;
 ssize_t xsendto(int s, const void *buf, size_t len, const struct sockaddr *to,
                                 socklen_t tolen) FAST_FUNC;
 
@@ -839,7 +919,36 @@ struct hostent *xgethostbyname(const char *name) FAST_FUNC;
 // Also mount.c and inetd.c are using gethostbyname(),
 // + inet_common.c has additional IPv4-only stuff
 
+#if defined CONFIG_FEATURE_TLS_SCHANNEL
+typedef struct tls_state {
+        int ofd;
+        int ifd;
+
+    // handles
+    CredHandle cred_handle;
+    CtxtHandle ctx_handle;
 
+    // buffers
+    char in_buffer[16384 + 256]; // input buffer (to read from server)
+    unsigned long in_buffer_size; // amount of data currently in input buffer
+
+    char *out_buffer; // output buffer (for decrypted data), this is essentially the same as input buffer as data is decrypted in place
+    unsigned long out_buffer_size; // amount of data currently in output buffer
+    unsigned long out_buffer_used; // amount of extra data currently in output buffer
+
+    // data
+    char *hostname;
+    SecPkgContext_StreamSizes stream_sizes;
+
+        // booleans
+
+        // context initialized
+    int initialized;
+
+        // closed by remote peer
+        int closed;
+} tls_state_t;
+#else
 struct tls_aes {
         uint32_t key[60];
         unsigned rounds;
@@ -896,12 +1005,14 @@ typedef struct tls_state {
         struct tls_aes aes_decrypt;
         uint8_t H[16]; //used by AES_GCM
 } tls_state_t;
+#endif
 
 static inline tls_state_t *new_tls_state(void)
 {
         tls_state_t *tls = xzalloc(sizeof(*tls));
         return tls;
 }
+
 void tls_handshake(tls_state_t *tls, const char *sni) FAST_FUNC;
 #define TLSLOOP_EXIT_ON_LOCAL_EOF (1 << 0)
 void tls_run_copy_loop(tls_state_t *tls, unsigned flags) FAST_FUNC;
@@ -933,7 +1044,7 @@ int bb_putchar(int ch) FAST_FUNC;
 /* Note: does not use stdio, writes to fd 2 directly */
 int bb_putchar_stderr(char ch) FAST_FUNC;
 int fputs_stdout(const char *s) FAST_FUNC;
-char *xasprintf(const char *format, ...) __attribute__ ((format(printf, 1, 2))) FAST_FUNC RETURNS_MALLOC;
+char *xasprintf(const char *format, ...) __attribute__ ((format(printf, 1, 2))) RETURNS_MALLOC;
 char *auto_string(char *str) FAST_FUNC;
 // gcc-4.1.1 still isn't good enough at optimizing it
 // (+200 bytes compared to macro)
@@ -1011,13 +1122,13 @@ unsigned bb_clk_tck(void) FAST_FUNC;
 
 #if SEAMLESS_COMPRESSION
 /* Autodetects gzip/bzip2 formats. fd may be in the middle of the file! */
-int setup_unzip_on_fd(int fd, int fail_if_not_compressed) FAST_FUNC;
+int setup_unzip_on_fd(int fd, int die_if_not_compressed) FAST_FUNC;
 /* Autodetects .gz etc */
-extern int open_zipped(const char *fname, int fail_if_not_compressed) FAST_FUNC;
+extern int open_zipped(const char *fname, int die_if_not_compressed) FAST_FUNC;
 extern void *xmalloc_open_zipped_read_close(const char *fname, size_t *maxsz_p) FAST_FUNC RETURNS_MALLOC;
 #else
 # define setup_unzip_on_fd(...) (0)
-# define open_zipped(fname, fail_if_not_compressed)  open((fname), O_RDONLY);
+# define open_zipped(fname, die_if_not_compressed)  open((fname), O_RDONLY);
 # define xmalloc_open_zipped_read_close(fname, maxsz_p) xmalloc_open_read_close((fname), (maxsz_p))
 #endif
 /* lzma has no signature, need a little helper. NB: exist only for ENABLE_FEATURE_SEAMLESS_LZMA=y */
@@ -1113,6 +1224,32 @@ char *bin2hex(char *dst, const char *src, int count) FAST_FUNC;
 /* Reverse */
 char* hex2bin(char *dst, const char *src, int count) FAST_FUNC;
 
+/* Returns strlen as a bonus */
+//size_t replace_char(char *s, char what, char with) FAST_FUNC;
+static inline size_t replace_char(char *str, char from, char to)
+{
+        char *p = str;
+        while (*p) {
+                if (*p == from)
+                        *p = to;
+                p++;
+        }
+        return p - str;
+}
+
+extern const char c_escape_conv_str00[];
+#define c_escape_conv_str07 (c_escape_conv_str00+3)
+
+void FAST_FUNC xorbuf_3(void *dst, const void *src1, const void *src2, unsigned count);
+void FAST_FUNC xorbuf(void* buf, const void* mask, unsigned count);
+void FAST_FUNC xorbuf16_aligned_long(void* buf, const void* mask);
+void FAST_FUNC xorbuf64_3_aligned64(void *dst, const void *src1, const void *src2);
+#if BB_UNALIGNED_MEMACCESS_OK
+# define xorbuf16(buf,mask) xorbuf16_aligned_long(buf,mask)
+#else
+void FAST_FUNC xorbuf16(void* buf, const void* mask);
+#endif
+
 /* Generate a UUID */
 void generate_uuid(uint8_t *buf) FAST_FUNC;
 
@@ -1208,12 +1345,20 @@ gid_t *bb_getgroups(int *ngroups, gid_t *group_array) FAST_FUNC;
 struct cached_groupinfo {
         uid_t euid;
         gid_t egid;
+#if !ENABLE_PLATFORM_MINGW32
+        // If these are ever restored on Windows it will be necessary to alter
+        // globals_misc_size()/globals_misc_copy() in ash.
         int ngroups;
         gid_t *supplementary_array;
+#endif
 };
 uid_t FAST_FUNC get_cached_euid(uid_t *euid);
 gid_t FAST_FUNC get_cached_egid(gid_t *egid);
+#if !ENABLE_PLATFORM_MINGW32
 int FAST_FUNC is_in_supplementary_groups(struct cached_groupinfo *groupinfo, gid_t gid);
+#else
+# define is_in_supplementary_groups(g, i) (FALSE)
+#endif
 
 #if ENABLE_FEATURE_UTMP
 void FAST_FUNC write_new_utmp(pid_t pid, int new_type, const char *tty_name, const char *username, const char *hostname);
@@ -1249,6 +1394,7 @@ void BB_EXECVP_or_die(char **argv) NORETURN FAST_FUNC;
 
 /* xvfork() can't be a _function_, return after vfork in child mangles stack
  * in the parent. It must be a macro. */
+#if !ENABLE_PLATFORM_MINGW32
 #define xvfork() \
 ({ \
         pid_t bb__xvfork_pid = vfork(); \
@@ -1256,6 +1402,9 @@ void BB_EXECVP_or_die(char **argv) NORETURN FAST_FUNC;
                 bb_simple_perror_msg_and_die("vfork"); \
         bb__xvfork_pid; \
 })
+#else
+#define xvfork() vfork()
+#endif
 #if BB_MMU
 pid_t xfork(void) FAST_FUNC;
 #endif
@@ -1290,6 +1439,15 @@ void run_noexec_applet_and_exit(int a, const char *name, char **argv) NORETURN F
 #ifndef BUILD_INDIVIDUAL
 int find_applet_by_name(const char *name) FAST_FUNC;
 void run_applet_no_and_exit(int a, const char *name, char **argv) NORETURN FAST_FUNC;
+# if ENABLE_PLATFORM_MINGW32
+#  if ENABLE_FEATURE_PREFER_APPLETS || ENABLE_FEATURE_SH_STANDALONE
+int prefer_applet(const char *name, const char *path) FAST_FUNC;
+int find_applet_by_name_for_sh(const char *name, const char *path) FAST_FUNC;
+#  endif
+# else
+#  define prefer_applet(n, p) (1)
+#  define find_applet_by_name_for_sh(n, p) find_applet_by_name(n)
+# endif
 #endif
 void show_usage_if_dash_dash_help(int applet_no, char **argv) FAST_FUNC;
 #if defined(__linux__)
@@ -1370,12 +1528,12 @@ char* single_argv(char **argv) FAST_FUNC;
 char **skip_dash_dash(char **argv) FAST_FUNC;
 extern const char *const bb_argv_dash[]; /* { "-", NULL } */
 extern uint32_t option_mask32;
-uint32_t getopt32(char **argv, const char *applet_opts, ...) FAST_FUNC;
+uint32_t getopt32(char **argv, const char *applet_opts, ...);
 # define No_argument "\0"
 # define Required_argument "\001"
 # define Optional_argument "\002"
 #if ENABLE_LONG_OPTS
-uint32_t getopt32long(char **argv, const char *optstring, const char *longopts, ...) FAST_FUNC;
+uint32_t getopt32long(char **argv, const char *optstring, const char *longopts, ...);
 #else
 #define getopt32long(argv,optstring,longopts,...) \
         getopt32(argv,optstring,##__VA_ARGS__)
@@ -1450,17 +1608,17 @@ extern uint8_t xfunc_error_retval;
 extern void (*die_func)(void);
 void xfunc_die(void) NORETURN FAST_FUNC;
 void bb_show_usage(void) NORETURN FAST_FUNC;
-void bb_error_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC;
+void bb_error_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2)));
 void bb_simple_error_msg(const char *s) FAST_FUNC;
-void bb_error_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))) FAST_FUNC;
+void bb_error_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2)));
 void bb_simple_error_msg_and_die(const char *s) NORETURN FAST_FUNC;
-void bb_perror_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC;
+void bb_perror_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2)));
 void bb_simple_perror_msg(const char *s) FAST_FUNC;
-void bb_perror_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))) FAST_FUNC;
+void bb_perror_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2)));
 void bb_simple_perror_msg_and_die(const char *s) NORETURN FAST_FUNC;
-void bb_herror_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC;
+void bb_herror_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2)));
 void bb_simple_herror_msg(const char *s) FAST_FUNC;
-void bb_herror_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))) FAST_FUNC;
+void bb_herror_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2)));
 void bb_simple_herror_msg_and_die(const char *s) NORETURN FAST_FUNC;
 void bb_perror_nomsg_and_die(void) NORETURN FAST_FUNC;
 void bb_perror_nomsg(void) FAST_FUNC;
@@ -1476,7 +1634,7 @@ void bb_logenv_override(void) FAST_FUNC;
 typedef smalluint exitcode_t;
 
 #if ENABLE_FEATURE_SYSLOG_INFO
-void bb_info_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC;
+void bb_info_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2)));
 void bb_simple_info_msg(const char *s) FAST_FUNC;
 void bb_vinfo_msg(const char *s, va_list p) FAST_FUNC;
 #else
@@ -1806,18 +1964,25 @@ extern char *pw_encrypt(const char *clear, const char *salt, int cleanup) FAST_F
 extern int obscure(const char *old, const char *newval, const struct passwd *pwdp) FAST_FUNC;
 /*
  * rnd is additional random input. New one is returned.
- * Useful if you call crypt_make_salt many times in a row:
- * rnd = crypt_make_salt(buf1, 4, 0);
- * rnd = crypt_make_salt(buf2, 4, rnd);
- * rnd = crypt_make_salt(buf3, 4, rnd);
+ * Useful if you call crypt_make_rand64encoded many times in a row:
+ * rnd = crypt_make_rand64encoded(buf1, 4, 0);
+ * rnd = crypt_make_rand64encoded(buf2, 4, rnd);
+ * rnd = crypt_make_rand64encoded(buf3, 4, rnd);
  * (otherwise we risk having same salt generated)
  */
-extern int crypt_make_salt(char *p, int cnt /*, int rnd*/) FAST_FUNC;
-/* "$N$" + sha_salt_16_bytes + NUL */
-#define MAX_PW_SALT_LEN (3 + 16 + 1)
+extern int crypt_make_rand64encoded(char *p, int cnt /*, int rnd*/) FAST_FUNC;
+/* Size of char salt[] to hold randomly-generated salt string
+ * sha256/512:
+ * "$5$" ["rounds=999999999$"] "<sha_salt_16_chars><NUL>"
+ * "$6$" ["rounds=999999999$"] "<sha_salt_16_chars><NUL>"
+ * #define MAX_PW_SALT_LEN (3 + sizeof("rounds=999999999$")-1 + 16 + 1)
+ * yescrypt:
+ * "$y$" <up to 8 params of up to 6 chars each> "$" <up to 86 chars salt><NUL>
+ * (86 chars are ascii64-encoded 64 binary bytes)
+ */
+#define MAX_PW_SALT_LEN (3 + 8*6 + 1 + 86 + 1)
 extern char* crypt_make_pw_salt(char p[MAX_PW_SALT_LEN], const char *algo) FAST_FUNC;
 
-
 /* Returns number of lines changed, or -1 on error */
 #if !(ENABLE_FEATURE_ADDUSER_TO_GROUP || ENABLE_FEATURE_DEL_USER_FROM_GROUP)
 #define update_passwd(filename, username, data, member) \
@@ -1853,8 +2018,8 @@ int get_termios_and_make_raw(int fd, struct termios *newterm, struct termios *ol
 int set_termios_to_raw(int fd, struct termios *oldterm, int flags) FAST_FUNC;
 
 /* NB: "unsigned request" is crucial! "int request" will break some arches! */
-int ioctl_or_perror(int fd, unsigned request, void *argp, const char *fmt,...) __attribute__ ((format (printf, 4, 5))) FAST_FUNC;
-int ioctl_or_perror_and_die(int fd, unsigned request, void *argp, const char *fmt,...) __attribute__ ((format (printf, 4, 5))) FAST_FUNC;
+int ioctl_or_perror(int fd, unsigned request, void *argp, const char *fmt,...) __attribute__ ((format (printf, 4, 5)));
+int ioctl_or_perror_and_die(int fd, unsigned request, void *argp, const char *fmt,...) __attribute__ ((format (printf, 4, 5)));
 #if ENABLE_IOCTL_HEX2STR_ERROR
 int bb_ioctl_or_warn(int fd, unsigned request, void *argp, const char *ioctl_name) FAST_FUNC;
 int bb_xioctl(int fd, unsigned request, void *argp, const char *ioctl_name) FAST_FUNC;
@@ -1867,9 +2032,15 @@ int bb_xioctl(int fd, unsigned request, void *argp) FAST_FUNC;
 #define xioctl(fd,request,argp)        bb_xioctl(fd,request,argp)
 #endif
 
+#if !ENABLE_PLATFORM_MINGW32 || ENABLE_FEATURE_EXTRA_FILE_DATA
 char *is_in_ino_dev_hashtable(const struct stat *statbuf) FAST_FUNC;
 void add_to_ino_dev_hashtable(const struct stat *statbuf, const char *name) FAST_FUNC;
 void reset_ino_dev_hashtable(void) FAST_FUNC;
+#else
+#define add_to_ino_dev_hashtable(s, n) (void)0
+#define is_in_ino_dev_hashtable(s) NULL
+#define reset_ino_dev_hashtable()
+#endif
 #ifdef __GLIBC__
 /* At least glibc has horrendously large inline for this, so wrap it */
 unsigned long long bb_makedev(unsigned major, unsigned minor) FAST_FUNC;
@@ -1947,10 +2118,17 @@ enum {
  * >=0: poll() for TIMEOUT milliseconds, return -1/EAGAIN on timeout
  */
 int64_t read_key(int fd, char *buffer, int timeout) FAST_FUNC;
+#if ENABLE_PLATFORM_MINGW32
+int64_t windows_read_key(int fd, char *buffer, int timeout) FAST_FUNC;
+#endif
 /* This version loops on EINTR: */
 int64_t safe_read_key(int fd, char *buffer, int timeout) FAST_FUNC;
 void read_key_ungets(char *buffer, const char *str, unsigned len) FAST_FUNC;
 
+int check_got_signal_and_poll(struct pollfd pfd[1], int timeout) FAST_FUNC;
+#if ENABLE_PLATFORM_MINGW32
+# define check_got_signal_and_poll(p, t) poll(p, 1, t)
+#endif
 
 #if ENABLE_FEATURE_EDITING
 /* It's NOT just ENABLEd or disabled. It's a number: */
@@ -1960,8 +2138,14 @@ unsigned size_from_HISTFILESIZE(const char *hp) FAST_FUNC;
 # else
 #  define MAX_HISTORY 0
 # endif
+# if defined CONFIG_FEATURE_EDITING_HISTORY_DEFAULT && CONFIG_FEATURE_EDITING_HISTORY_DEFAULT > 0
+#  define DEFAULT_HISTORY (CONFIG_FEATURE_EDITING_HISTORY_DEFAULT + 0)
+# else
+#  define DEFAULT_HISTORY 0
+# endif
 typedef const char *get_exe_name_t(int i) FAST_FUNC;
 typedef const char *sh_get_var_t(const char *name) FAST_FUNC;
+typedef int sh_accept_glob_t(const char *name) FAST_FUNC;
 typedef struct line_input_t {
         int flags;
         int timeout;
@@ -1975,6 +2159,9 @@ typedef struct line_input_t {
 #  if ENABLE_SHELL_ASH || ENABLE_SHELL_HUSH
         /* function to fetch additional application-specific names to match */
         get_exe_name_t *get_exe_name;
+#   if ENABLE_ASH_GLOB_OPTIONS
+        sh_accept_glob_t *sh_accept_glob;
+#   endif
 #  endif
 # endif
 # if (ENABLE_FEATURE_USERNAME_COMPLETION || ENABLE_FEATURE_EDITING_FANCY_PROMPT) \
@@ -1988,7 +2175,7 @@ typedef struct line_input_t {
 # if MAX_HISTORY
         int cnt_history;
         int cur_history;
-        int max_history; /* must never be <= 0 */
+        int max_history; /* must never be < 0 */
 #  if ENABLE_FEATURE_EDITING_SAVEHISTORY
         /* meaning of this field depends on FEATURE_EDITING_SAVE_ON_EXIT:
          * if !FEATURE_EDITING_SAVE_ON_EXIT: "how many lines are
@@ -2009,6 +2196,9 @@ enum {
         VI_MODE          = 8 * ENABLE_FEATURE_EDITING_VI,
         WITH_PATH_LOOKUP = 0x10,
         LI_INTERRUPTIBLE = 0x20,
+#if ENABLE_PLATFORM_MINGW32
+        IGNORE_CTRL_C    = 0x40,
+#endif
         FOR_SHELL        = DO_HISTORY | TAB_COMPLETION | USERNAME_COMPLETION | LI_INTERRUPTIBLE,
 };
 line_input_t *new_line_input_t(int flags) FAST_FUNC;
@@ -2038,6 +2228,10 @@ int read_line_input(const char* prompt, char* command, int maxsize) FAST_FUNC;
 
 unsigned long* FAST_FUNC get_malloc_cpu_affinity(int pid, unsigned *sz);
 
+#if ENABLE_PLATFORM_MINGW32
+# undef COMM_LEN
+# define COMM_LEN 32
+#endif
 #ifndef COMM_LEN
 # ifdef TASK_COMM_LEN
 enum { COMM_LEN = TASK_COMM_LEN };
@@ -2047,35 +2241,14 @@ enum { COMM_LEN = 16 };
 # endif
 #endif
 
-struct smaprec {
-        unsigned long mapped_rw;
-        unsigned long mapped_ro;
-        unsigned long shared_clean;
-        unsigned long shared_dirty;
-        unsigned long private_clean;
-        unsigned long private_dirty;
-        unsigned long stack;
-        unsigned long smap_pss, smap_swap;
-        unsigned long smap_size;
-        // For mixed 32/64 userspace, 32-bit pmap still needs
-        // 64-bit field here to correctly show 64-bit processes:
-        unsigned long long smap_start;
-        // (strictly speaking, other fields need to be wider too,
-        // but they are in kbytes, not bytes, and they hold sizes,
-        // not start addresses, sizes tend to be less than 4 terabytes)
-        char smap_mode[5];
-        char *smap_name;
-};
-
-#if !ENABLE_PMAP
-#define procps_read_smaps(pid, total, cb, data) \
-        procps_read_smaps(pid, total)
-#endif
-int FAST_FUNC procps_read_smaps(pid_t pid, struct smaprec *total,
-                void (*cb)(struct smaprec *, void *), void *data);
-
 typedef struct procps_status_t {
+#if !ENABLE_PLATFORM_MINGW32
         DIR *dir;
+#else
+        HANDLE snapshot;
+        DWORD *pids;
+        int npids;
+#endif
         IF_FEATURE_SHOW_THREADS(DIR *task_dir;)
         uint8_t shift_pages_to_bytes;
         uint8_t shift_pages_to_kb;
@@ -2103,7 +2276,13 @@ typedef struct procps_status_t {
 #endif
         unsigned tty_major,tty_minor;
 #if ENABLE_FEATURE_TOPMEM
-        struct smaprec smaps;
+        unsigned long mapped_rw;
+        unsigned long mapped_ro;
+        unsigned long shared_clean;
+        unsigned long shared_dirty;
+        unsigned long private_clean;
+        unsigned long private_dirty;
+        unsigned long stack;
 #endif
         char state[4];
         /* basename of executable in exec(2), read from /proc/N/stat
@@ -2152,11 +2331,15 @@ void free_procps_scan(procps_status_t* sp) FAST_FUNC;
 procps_status_t* procps_scan(procps_status_t* sp, int flags) FAST_FUNC;
 /* Format cmdline (up to col chars) into char buf[size] */
 /* Puts [comm] if cmdline is empty (-> process is a kernel thread) */
-void read_cmdline(char *buf, int size, unsigned pid, const char *comm) FAST_FUNC;
+int read_cmdline(char *buf, int size, unsigned pid, const char *comm) FAST_FUNC;
 pid_t *find_pid_by_name(const char* procName) FAST_FUNC;
 pid_t *pidlist_reverse(pid_t *pidList) FAST_FUNC;
 int starts_with_cpu(const char *str) FAST_FUNC;
 unsigned get_cpu_count(void) FAST_FUNC;
+/* Some internals reused by pmap: */
+unsigned long FAST_FUNC fast_strtoul_10(char **endptr);
+unsigned long long FAST_FUNC fast_strtoull_16(char **endptr);
+char* FAST_FUNC skip_fields(char *str, int count);
 
 
 /* Use strict=1 if you process input from untrusted source:
@@ -2182,6 +2365,56 @@ char *decode_base64(char *dst, const char **pp_src) FAST_FUNC;
 char *decode_base32(char *dst, const char **pp_src) FAST_FUNC;
 void read_base64(FILE *src_stream, FILE *dst_stream, int flags) FAST_FUNC;
 
+int FAST_FUNC i2a64(int i);
+int FAST_FUNC a2i64(char c);
+char* FAST_FUNC num2str64_lsb_first(char *s, unsigned v, int n);
+
+enum {
+        /* how many bytes XYZ_end() fills */
+        MD5_OUTSIZE    = 16,
+        SHA1_OUTSIZE   = 20,
+        SHA256_OUTSIZE = 32,
+        SHA384_OUTSIZE = 48,
+        SHA512_OUTSIZE = 64,
+        //SHA3-224_OUTSIZE = 28,
+        /* size of input block */
+        SHA2_INSIZE     = 64,
+};
+
+#if defined CONFIG_FEATURE_USE_CNG_API
+struct bcrypt_hash_ctx_t {
+        void *handle;
+        void *hash_obj;
+        unsigned int output_size;
+};
+typedef struct bcrypt_hash_ctx_t md5_ctx_t;
+typedef struct bcrypt_hash_ctx_t sha1_ctx_t;
+typedef struct bcrypt_hash_ctx_t sha256_ctx_t;
+typedef struct bcrypt_hash_ctx_t sha384_ctx_t;
+typedef struct bcrypt_hash_ctx_t sha512_ctx_t;
+typedef struct sha3_ctx_t {
+        uint64_t state[25];
+        unsigned bytes_queued;
+        unsigned input_block_bytes;
+} sha3_ctx_t;
+void md5_begin(struct bcrypt_hash_ctx_t *ctx) FAST_FUNC;
+void sha1_begin(struct bcrypt_hash_ctx_t *ctx) FAST_FUNC;
+void sha256_begin(struct bcrypt_hash_ctx_t *ctx) FAST_FUNC;
+void sha384_begin(struct bcrypt_hash_ctx_t *ctx) FAST_FUNC;
+void sha512_begin(struct bcrypt_hash_ctx_t *ctx) FAST_FUNC;
+void generic_hash(struct bcrypt_hash_ctx_t *ctx, const void *buffer, size_t len) FAST_FUNC;
+unsigned generic_end(struct bcrypt_hash_ctx_t *ctx, void *resbuf) FAST_FUNC;
+# define md5_hash generic_hash
+# define sha1_hash generic_hash
+# define sha256_hash generic_hash
+# define sha384_hash generic_hash
+# define sha512_hash generic_hash
+# define md5_end generic_end
+# define sha1_end generic_end
+# define sha256_end generic_end
+# define sha384_end generic_end
+# define sha512_end generic_end
+#else
 typedef struct md5_ctx_t {
         uint8_t wbuffer[64]; /* always correctly aligned for uint64_t */
         void (*process_block)(struct md5_ctx_t*) FAST_FUNC;
@@ -2195,6 +2428,7 @@ typedef struct sha512_ctx_t {
         uint64_t hash[8];
         uint8_t wbuffer[128]; /* always correctly aligned for uint64_t */
 } sha512_ctx_t;
+typedef struct sha512_ctx_t sha384_ctx_t;
 typedef struct sha3_ctx_t {
         uint64_t state[25];
         unsigned bytes_queued;
@@ -2212,20 +2446,69 @@ void sha256_begin(sha256_ctx_t *ctx) FAST_FUNC;
 void sha512_begin(sha512_ctx_t *ctx) FAST_FUNC;
 void sha512_hash(sha512_ctx_t *ctx, const void *buffer, size_t len) FAST_FUNC;
 unsigned sha512_end(sha512_ctx_t *ctx, void *resbuf) FAST_FUNC;
+void sha384_begin(sha384_ctx_t *ctx) FAST_FUNC;
+#define sha384_hash sha512_hash
+unsigned sha384_end(sha384_ctx_t *ctx, void *resbuf) FAST_FUNC;
+#endif
 void sha3_begin(sha3_ctx_t *ctx) FAST_FUNC;
 void sha3_hash(sha3_ctx_t *ctx, const void *buffer, size_t len) FAST_FUNC;
 unsigned sha3_end(sha3_ctx_t *ctx, void *resbuf) FAST_FUNC;
+void FAST_FUNC sha256_block(const void *in, size_t len, uint8_t hash[32]);
 /* TLS benefits from knowing that sha1 and sha256 share these. Give them "agnostic" names too */
+#if defined CONFIG_FEATURE_USE_CNG_API
+typedef struct bcrypt_hash_ctx_t md5sha_ctx_t;
+#define md5sha_hash generic_hash
+#define sha_end generic_end
+#else
 typedef struct md5_ctx_t md5sha_ctx_t;
 #define md5sha_hash md5_hash
 #define sha_end sha1_end
-enum {
-        MD5_OUTSIZE    = 16,
-        SHA1_OUTSIZE   = 20,
-        SHA256_OUTSIZE = 32,
-        SHA512_OUTSIZE = 64,
-        SHA3_OUTSIZE   = 28,
-};
+#endif
+
+/* RFC 2104 HMAC (hash-based message authentication code) */
+#if !ENABLE_FEATURE_USE_CNG_API
+typedef struct hmac_ctx {
+        md5sha_ctx_t hashed_key_xor_ipad;
+        md5sha_ctx_t hashed_key_xor_opad;
+} hmac_ctx_t;
+#else
+typedef struct bcrypt_hash_ctx_t hmac_ctx_t;
+#endif
+#define HMAC_ONLY_SHA256 (!ENABLE_FEATURE_TLS_SHA1)
+typedef void md5sha_begin_func(md5sha_ctx_t *ctx) FAST_FUNC;
+#if !ENABLE_FEATURE_USE_CNG_API
+#if HMAC_ONLY_SHA256
+#define hmac_begin(ctx,key,key_size,begin) \
+        hmac_begin(ctx,key,key_size)
+#endif
+void FAST_FUNC hmac_begin(hmac_ctx_t *ctx, const uint8_t *key, unsigned key_size, md5sha_begin_func *begin);
+static ALWAYS_INLINE void hmac_hash(hmac_ctx_t *ctx, const void *in, size_t len)
+{
+        md5sha_hash(&ctx->hashed_key_xor_ipad, in, len);
+}
+#else
+# if HMAC_ONLY_SHA256
+#  define hmac_begin(pre,key,key_size,begin) \
+        _hmac_begin(pre, key, key_size, sha256_begin_hmac)
+# else
+#  define hmac_begin _hmac_begin
+# endif
+void _hmac_begin(hmac_ctx_t *pre, uint8_t *key, unsigned key_size,
+        BCRYPT_ALG_HANDLE alg_handle);
+void hmac_uninit(hmac_ctx_t *pre);
+#endif
+unsigned FAST_FUNC hmac_end(hmac_ctx_t *ctx, uint8_t *out);
+#if HMAC_ONLY_SHA256
+#define hmac_block(key,key_size,begin,in,sz,out) \
+        hmac_block(key,key_size,in,sz,out)
+#endif
+unsigned FAST_FUNC hmac_block(const uint8_t *key, unsigned key_size,
+                md5sha_begin_func *begin,
+                const void *in, unsigned sz,
+                uint8_t *out);
+/* HMAC helpers for TLS: */
+void FAST_FUNC hmac_hash_v(hmac_ctx_t *ctx, va_list va);
+unsigned hmac_peek_hash(hmac_ctx_t *ctx, uint8_t *out, ...);
 
 extern uint32_t *global_crc32_table;
 uint32_t *crc32_filltable(uint32_t *tbl256, int endian) FAST_FUNC;
@@ -2309,11 +2592,18 @@ extern const char bb_path_wtmp_file[] ALIGN1;
 #define bb_path_motd_file "/etc/motd"
 
 #define bb_dev_null "/dev/null"
+#if ENABLE_PLATFORM_MINGW32
+#define bb_busybox_exec_path get_busybox_exec_path()
+extern char bb_comm[];
+extern char bb_command_line[];
+#else
 extern const char bb_busybox_exec_path[] ALIGN1;
+#endif
 /* allow default system PATH to be extended via CFLAGS */
 #ifndef BB_ADDITIONAL_PATH
 #define BB_ADDITIONAL_PATH ""
 #endif
+#if !ENABLE_PLATFORM_MINGW32
 #define BB_PATH_ROOT_PATH "PATH=/sbin:/usr/sbin:/bin:/usr/bin" BB_ADDITIONAL_PATH
 extern const char bb_PATH_root_path[] ALIGN1; /* BB_PATH_ROOT_PATH */
 #define bb_default_root_path (bb_PATH_root_path + sizeof("PATH"))
@@ -2321,6 +2611,23 @@ extern const char bb_PATH_root_path[] ALIGN1; /* BB_PATH_ROOT_PATH */
  * but I want to save a few bytes here:
  */
 #define bb_default_path      (bb_PATH_root_path + sizeof("PATH=/sbin:/usr/sbin"))
+#define PATH_SEP ':'
+#define PATH_SEP_STR ":"
+#else
+#define BB_PATH_ROOT_PATH "PATH=C:/Windows/System32;C:/Windows" BB_ADDITIONAL_PATH
+extern const char bb_PATH_root_path[] ALIGN1; /* BB_PATH_ROOT_PATH */
+#define bb_default_root_path (bb_PATH_root_path + sizeof("PATH"))
+#define bb_default_path      (bb_PATH_root_path + sizeof("PATH"))
+#define PATH_SEP ';'
+#define PATH_SEP_STR ";"
+extern const char bbvar[] ALIGN1;
+#define bbafter(p) (p + sizeof(#p))
+#define BB_OVERRIDE_APPLETS bbvar
+#define BB_SKIP_ANSI_EMULATION bbafter(BB_OVERRIDE_APPLETS)
+#define BB_TERMINAL_MODE bbafter(BB_SKIP_ANSI_EMULATION)
+#define BB_SYSTEMROOT bbafter(BB_TERMINAL_MODE)
+#define BB_CRITICAL_ERROR_DIALOGS bbafter(BB_SYSTEMROOT)
+#endif
 
 extern const int const_int_0;
 //extern const int const_int_1;
@@ -2337,26 +2644,10 @@ extern struct globals *BB_GLOBAL_CONST ptr_to_globals;
 #define barrier() asm volatile ("":::"memory")
 
 #if defined(__clang_major__) && __clang_major__ >= 9
-/* Clang/llvm drops assignment to "constant" storage. Silently.
- * Needs serious convincing to not eliminate the store.
- */
-static ALWAYS_INLINE void* not_const_pp(const void *p)
-{
-        void *pp;
-        asm volatile (
-                "# forget that p points to const"
-                : /*outputs*/ "=r" (pp)
-                : /*inputs*/ "0" (p)
-        );
-        return pp;
-}
-# define ASSIGN_CONST_PTR(pptr, v) do { \
-        *(void**)not_const_pp(pptr) = (void*)(v); \
-        barrier(); \
-} while (0)
-/* XZALLOC_CONST_PTR() is an out-of-line function to prevent
- * clang from reading pointer before it is assigned.
+/* {ASSIGN,XZALLOC}_CONST_PTR() are out-of-line functions
+ * to prevent clang from reading pointer before it is assigned.
  */
+void ASSIGN_CONST_PTR(const void *pptr, void *v) FAST_FUNC;
 void XZALLOC_CONST_PTR(const void *pptr, size_t size) FAST_FUNC;
 #else
 # define ASSIGN_CONST_PTR(pptr, v) do { \
diff --git a/include/mingw.h b/include/mingw.h
new file mode 100644
index 000000000..276e40659
--- /dev/null
+++ b/include/mingw.h
@@ -0,0 +1,674 @@
+
+#define NOIMPL(name,...) static inline int name(__VA_ARGS__) { errno = ENOSYS; return -1; }
+#define IMPL(name,ret,retval,...) static inline ret name(__VA_ARGS__) { return retval; }
+
+/* Use 64-bit time on 32-bit platforms. */
+#if !defined(_WIN64)
+# define time_t __time64_t
+# define ctime(t) _ctime64(t)
+# define localtime(t) _localtime64(t)
+# define time(t) _time64(t)
+# define gmtime(t) _gmtime64(t)
+# define mktime(t) _mktime64(t)
+# define timespec _timespec64
+#endif
+
+/*
+ * sys/types.h
+ */
+typedef int gid_t;
+typedef int uid_t;
+
+#define DEFAULT_UID 4095
+#define DEFAULT_GID DEFAULT_UID
+
+/*
+ * arpa/inet.h
+ */
+static inline unsigned int git_ntohl(unsigned int x) { return (unsigned int)ntohl(x); }
+#define ntohl git_ntohl
+int inet_aton(const char *cp, struct in_addr *inp);
+int inet_pton(int af, const char *src, void *dst);
+
+/*
+ * fcntl.h
+ */
+#define F_DUPFD 0
+#define F_GETFD 1
+#define F_SETFD 2
+#define F_GETFL 3
+#define F_SETFL 3
+#define FD_CLOEXEC 0x1
+#define O_NONBLOCK 0
+#define O_NOFOLLOW 0
+#define O_NOCTTY 0
+#define O_DIRECT 0
+#define O_SPECIAL 0x800000
+
+#define AT_FDCWD -100
+#define AT_SYMLINK_NOFOLLOW 0x100
+
+/*
+ * grp.h
+ */
+
+struct group {
+        char *gr_name;
+        char *gr_passwd;
+        gid_t gr_gid;
+        char **gr_mem;
+};
+IMPL(getgrnam,struct group *,NULL,const char *name UNUSED_PARAM);
+struct group *getgrgid(gid_t gid);
+NOIMPL(initgroups,const char *group UNUSED_PARAM,gid_t gid UNUSED_PARAM);
+static inline void endgrent(void) {}
+int getgrouplist(const char *user, gid_t group, gid_t *groups, int *ngroups);
+
+/*
+ * limits.h
+ */
+#define NAME_MAX 255
+#define MAXSYMLINKS 20
+
+#ifdef LONG_MAX
+# if LONG_MAX == 2147483647
+#  define LONG_BIT  32
+# else
+/* Safe assumption.  */
+#  define LONG_BIT  64
+# endif
+#elif defined __LONG_MAX__
+# if __LONG_MAX__ == 2147483647
+#  define LONG_BIT  32
+# else
+/* Safe assumption.  */
+#  define LONG_BIT  64
+# endif
+#endif
+
+/*
+ * netdb.h
+ */
+
+typedef int sa_family_t;
+
+/*
+ * linux/un.h
+ */
+struct sockaddr_un {
+        sa_family_t sun_family;
+        char sun_path[1]; /* to make compiler happy, don't bother */
+};
+
+/*
+ * pwd.h
+ */
+struct passwd {
+        char *pw_name;
+        char *pw_passwd;
+        char *pw_gecos;
+        char *pw_dir;
+        char *pw_shell;
+        uid_t pw_uid;
+        gid_t pw_gid;
+};
+
+struct passwd *getpwnam(const char *name);
+struct passwd *getpwuid(uid_t uid);
+static inline void setpwent(void) {}
+static inline void endpwent(void) {}
+IMPL(getpwent_r,int,ENOENT,struct passwd *pwbuf UNUSED_PARAM,char *buf UNUSED_PARAM,size_t buflen UNUSED_PARAM,struct passwd **pwbufp UNUSED_PARAM);
+IMPL(getpwent,struct passwd *,NULL,void)
+
+/*
+ * signal.h
+ */
+#define SIGHUP  1
+#define SIGQUIT 3
+#define SIGKILL 9
+#define SIGPIPE 13
+
+#define SIG_UNBLOCK 1
+
+typedef void (*sighandler_t)(int);
+sighandler_t winansi_signal(int signum, sighandler_t handler);
+#define signal(s, h) winansi_signal(s, h)
+
+/*
+ * stdio.h
+ */
+#undef fseeko
+#define fseeko(f,o,w) fseek(f,o,w)
+
+int fdprintf(int fd, const char *format, ...);
+FILE* mingw_fopen(const char *filename, const char *mode);
+int mingw_rename(const char*, const char*);
+#define fopen mingw_fopen
+#define rename mingw_rename
+
+FILE *mingw_popen(const char *cmd, const char *mode);
+int mingw_popen_fd(const char *exe, const char *cmd, const char *mode,
+                                        int fd0, pid_t *pid);
+int mingw_pclose(FILE *fd);
+pid_t mingw_fork_compressor(int fd, const char *compressor, const char *mode);
+#undef popen
+#undef pclose
+#define popen mingw_popen
+#define pclose mingw_pclose
+
+IMPL(setlinebuf, void, ,FILE *fd UNUSED_PARAM)
+
+/*
+ * ANSI emulation wrappers
+ */
+
+BOOL conToCharBuffA(LPSTR d, DWORD len);
+BOOL conToCharA(LPSTR d);
+
+// same as ReadConsoleInputA, but delivers UTF8 regardless of console CP
+BOOL readConsoleInput_utf8(HANDLE h, INPUT_RECORD *r, DWORD len, DWORD *got);
+
+void set_title(const char *str);
+int get_title(char *buf, int len);
+void move_cursor_row(int n);
+void reset_screen(void);
+int winansi_putchar(int c);
+int winansi_puts(const char *s);
+size_t winansi_fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
+int winansi_fputs(const char *str, FILE *stream);
+int winansi_fputc(int c, FILE *stream);
+int winansi_vsnprintf(char *buf, size_t size, const char *format, va_list list);
+int winansi_vfprintf(FILE *stream, const char *format, va_list list);
+int winansi_printf(const char *format, ...) __attribute__((format (printf, 1, 2)));
+int winansi_fprintf(FILE *stream, const char *format, ...) __attribute__((format (printf, 2, 3)));
+int winansi_write(int fd, const void *buf, size_t count);
+int winansi_read(int fd, void *buf, size_t count);
+size_t winansi_fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
+int winansi_getc(FILE *stream);
+int winansi_getchar(void);
+char *winansi_fgets(char *s, int size, FILE *stream);
+void console_write(const char *str, int len);
+
+#define putchar winansi_putchar
+#define puts winansi_puts
+#define fwrite winansi_fwrite
+#define fputs winansi_fputs
+#define fputc winansi_fputc
+#if !defined(__USE_MINGW_ANSI_STDIO) || !__USE_MINGW_ANSI_STDIO
+#define vsnprintf(buf, size, ...) winansi_vsnprintf(buf, size,  __VA_ARGS__)
+#endif
+#define vfprintf(stream, ...) winansi_vfprintf(stream, __VA_ARGS__)
+#define vprintf(...) winansi_vfprintf(stdout, __VA_ARGS__)
+#define printf(...) winansi_printf(__VA_ARGS__)
+#define fprintf(...) winansi_fprintf(__VA_ARGS__)
+#define write winansi_write
+#define read winansi_read
+#define fread winansi_fread
+#define getc winansi_getc
+#define fgetc winansi_getc
+#define getchar winansi_getchar
+#define fgets winansi_fgets
+
+/*
+ * stdlib.h
+ */
+#define WTERMSIG(x) ((x) & 0x7f)
+#define WIFEXITED(x) (WTERMSIG(x) == 0)
+#define WEXITSTATUS(x) (((x) & 0xff00) >> 8)
+#define WIFSIGNALED(x) (((signed char) (((x) & 0x7f) + 1) >> 1) > 0)
+#define WCOREDUMP(x) 0
+#define WIFSTOPPED(x) 0
+
+int mingw_system(const char *cmd);
+#define system mingw_system
+
+int clearenv(void);
+char *mingw_getenv(const char *name);
+int mingw_putenv(const char *env);
+char *mingw_mktemp(char *template);
+int mkstemp(char *template);
+char *realpath(const char *path, char *resolved_path);
+int setenv(const char *name, const char *value, int replace);
+int unsetenv(const char *env);
+
+#define getenv mingw_getenv
+#define putenv mingw_putenv
+#define mktemp mingw_mktemp
+
+/*
+ * string.h
+ */
+char *strndup(char const *s, size_t n);
+char *mingw_strerror(int errnum);
+char *strsignal(int sig);
+int strverscmp(const char *s1, const char *s2);
+
+#define strerror mingw_strerror
+
+/*
+ * strings.h
+ */
+#if !defined(__GNUC__)
+int ffs(int i);
+#else
+# define ffs(i) __builtin_ffs(i)
+#endif
+
+/*
+ * sys/ioctl.h
+ */
+
+#define TIOCGWINSZ 0x5413
+#define TIOCSWINSZ 0x5414
+
+int ioctl(int fd, int code, ...);
+
+/*
+ * sys/socket.h
+ */
+#define hstrerror strerror
+
+#define SHUT_WR SD_SEND
+
+int mingw_socket(int domain, int type, int protocol);
+int mingw_connect(int sockfd, const struct sockaddr *sa, size_t sz);
+int mingw_bind(int sockfd, struct sockaddr *sa, size_t sz);
+int mingw_setsockopt(int sockfd, int lvl, int optname, void *optval, int optlen);
+int mingw_shutdown(int sockfd, int how);
+int mingw_listen(int sockfd, int backlog);
+int mingw_accept(int sockfd1, struct sockaddr *sa, socklen_t *sz);
+int mingw_select (int nfds, fd_set *rfds, fd_set *wfds, fd_set *xfds,
+            struct timeval *timeout);
+int mingw_getpeername(int fd, struct sockaddr *sa, socklen_t *sz);
+int mingw_gethostname(char *host, int namelen);
+int mingw_getaddrinfo(const char *node, const char *service,
+                        const struct addrinfo *hints, struct addrinfo **res);
+struct hostent *mingw_gethostbyaddr(const void *addr, socklen_t len, int type);
+
+#define socket mingw_socket
+#define connect mingw_connect
+#define listen mingw_listen
+#define bind mingw_bind
+#define setsockopt mingw_setsockopt
+#define shutdown mingw_shutdown
+#define accept mingw_accept
+#define select mingw_select
+#define getpeername mingw_getpeername
+#define gethostname mingw_gethostname
+#define getaddrinfo mingw_getaddrinfo
+#define gethostbyaddr mingw_gethostbyaddr
+
+/*
+ * sys/time.h
+ */
+#ifndef _TIMESPEC_DEFINED
+#define _TIMESPEC_DEFINED
+struct timespec {
+        time_t tv_sec;
+        long int tv_nsec;
+};
+#endif
+
+typedef int clockid_t;
+#define CLOCK_REALTIME 0
+
+time_t timegm(struct tm *tm);
+
+int nanosleep(const struct timespec *req, struct timespec *rem);
+int clock_gettime(clockid_t clockid, struct timespec *tp);
+int clock_settime(clockid_t clockid, const struct timespec *tp);
+
+/*
+ * sys/stat.h
+ */
+#define S_ISUID 04000
+#define S_ISGID 02000
+#define S_ISVTX 01000
+#ifndef S_IRWXU
+#define S_IRWXU (S_IRUSR | S_IWUSR | S_IXUSR)
+#endif
+#define S_IRWXG (S_IRWXU >> 3)
+#define S_IRWXO (S_IRWXG >> 3)
+
+#define S_IFSOCK 0140000
+#define S_IFLNK    0120000 /* Symbolic link */
+#define S_ISLNK(x) (((x) & S_IFMT) == S_IFLNK)
+#define S_ISSOCK(x) 0
+
+#define S_IRGRP (S_IRUSR >> 3)
+#define S_IWGRP (S_IWUSR >> 3)
+#define S_IXGRP (S_IXUSR >> 3)
+#define S_IROTH (S_IRGRP >> 3)
+#define S_IWOTH (S_IWGRP >> 3)
+#define S_IXOTH (S_IXGRP >> 3)
+
+mode_t mingw_umask(mode_t mode);
+#define umask mingw_umask
+
+#define DEFAULT_UMASK 0002
+
+IMPL(fchmod,int,0,int fildes UNUSED_PARAM, mode_t mode UNUSED_PARAM);
+NOIMPL(fchown,int fd UNUSED_PARAM, uid_t uid UNUSED_PARAM, gid_t gid UNUSED_PARAM);
+int mingw_mkdir(const char *path, int mode);
+int mingw_chdir(const char *path);
+int mingw_chmod(const char *path, int mode);
+
+#define mkdir mingw_mkdir
+#define chdir mingw_chdir
+#define chmod mingw_chmod
+
+#if ENABLE_LFS && !defined(__MINGW64_VERSION_MAJOR)
+# define off_t off64_t
+#endif
+
+typedef int nlink_t;
+typedef int blksize_t;
+typedef off_t blkcnt_t;
+#if ENABLE_FEATURE_EXTRA_FILE_DATA
+#define ino_t uint64_t
+#endif
+
+struct mingw_stat {
+        dev_t     st_dev;
+        ino_t     st_ino;
+        mode_t    st_mode;
+        nlink_t   st_nlink;
+        uid_t     st_uid;
+        gid_t     st_gid;
+        dev_t     st_rdev;
+        off_t     st_size;
+        struct timespec st_atim;
+        struct timespec st_mtim;
+        struct timespec st_ctim;
+        blksize_t st_blksize;
+        blkcnt_t  st_blocks;
+        DWORD     st_attr;
+        DWORD     st_tag;
+};
+#define st_atime st_atim.tv_sec
+#define st_mtime st_mtim.tv_sec
+#define st_ctime st_ctim.tv_sec
+
+int count_subdirs(const char *pathname);
+int mingw_lstat(const char *file_name, struct mingw_stat *buf);
+int mingw_stat(const char *file_name, struct mingw_stat *buf);
+int mingw_fstat(int fd, struct mingw_stat *buf);
+#undef lstat
+#undef stat
+#undef fstat
+#define lstat mingw_lstat
+#define stat mingw_stat
+#define fstat mingw_fstat
+
+#define UTIME_NOW  ((1l << 30) - 1l)
+#define UTIME_OMIT ((1l << 30) - 2l)
+
+int utimensat(int fd, const char *path, const struct timespec times[2],
+                                int flags);
+int futimens(int fd, const struct timespec times[2]);
+
+/*
+ * sys/sysinfo.h
+ */
+struct sysinfo {
+        long uptime;             /* Seconds since boot */
+        unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
+        unsigned long totalram;  /* Total usable main memory size */
+        unsigned long freeram;   /* Available memory size */
+        unsigned long sharedram; /* Amount of shared memory */
+        unsigned long bufferram; /* Memory used by buffers */
+        unsigned long totalswap; /* Total swap space size */
+        unsigned long freeswap;  /* Swap space still available */
+        unsigned short procs;    /* Number of current processes */
+        unsigned long totalhigh; /* Total high memory size */
+        unsigned long freehigh;  /* Available high memory size */
+        unsigned int mem_unit;   /* Memory unit size in bytes */
+};
+
+int sysinfo(struct sysinfo *info);
+
+/*
+ * sys/sysmacros.h
+ */
+#define makedev(a,b) 0*(a)*(b) /* avoid unused warning */
+#define minor(x) 0
+#define major(x) 0
+
+/*
+ * sys/wait.h
+ */
+#define WNOHANG 1
+#define WUNTRACED 2
+pid_t waitpid(pid_t pid, int *status, int options);
+pid_t mingw_wait3(pid_t pid, int *status, int options, struct rusage *rusage);
+
+/*
+ * time.h
+ */
+struct tm *gmtime_r(const time_t *timep, struct tm *result);
+struct tm *localtime_r(const time_t *timep, struct tm *result);
+char *strptime(const char *s, const char *format, struct tm *tm);
+char *mingw_strptime(const char *s, const char *format, struct tm *tm, long *gmt);
+size_t mingw_strftime(char *buf, size_t max, const char *format, const struct tm *tm);
+
+#define strftime mingw_strftime
+
+/*
+ * times.h
+ */
+#define clock_t long
+
+struct tms {
+        clock_t tms_utime;              /* user CPU time */
+        clock_t tms_stime;              /* system CPU time */
+        clock_t tms_cutime;             /* user CPU time of children */
+        clock_t tms_cstime;             /* system CPU time of children */
+};
+
+clock_t times(struct tms *buf);
+
+/*
+ * unistd.h
+ */
+#define PIPE_BUF 8192
+
+#define _SC_CLK_TCK 2
+
+#define TICKS_PER_SECOND 100
+#define MS_PER_TICK 10
+#define HNSEC_PER_TICK 100000
+
+IMPL(alarm,unsigned int,0,unsigned int seconds UNUSED_PARAM);
+IMPL(chown,int,0,const char *path UNUSED_PARAM, uid_t uid UNUSED_PARAM, gid_t gid UNUSED_PARAM);
+NOIMPL(chroot,const char *root UNUSED_PARAM);
+NOIMPL(fchdir,int fd UNUSED_PARAM);
+int mingw_dup2 (int fd, int fdto);
+char *mingw_getcwd(char *pointer, int len);
+off_t mingw_lseek(int fd, off_t offset, int whence);
+
+
+int getuid(void);
+#define getgid getuid
+#define geteuid getuid
+#define getegid getuid
+int getgroups(int n, gid_t *groups);
+pid_t getppid(void);
+NOIMPL(getsid,pid_t pid UNUSED_PARAM);
+int getlogin_r(char *buf, size_t len);
+int fcntl(int fd, int cmd, ...);
+int fsync(int fd);
+int kill(pid_t pid, int sig);
+int link(const char *oldpath, const char *newpath);
+NOIMPL(mknod,const char *name UNUSED_PARAM, mode_t mode UNUSED_PARAM, dev_t device UNUSED_PARAM);
+/* order of devices must match that in get_dev_type */
+enum {DEV_NULL, DEV_ZERO, DEV_URANDOM, NOT_DEVICE = -1};
+int get_dev_type(const char *filename);
+void update_special_fd(int dev, int fd);
+int mingw_open (const char *filename, int oflags, ...);
+
+/* functions which add O_SPECIAL to open(2) to allow access to devices */
+int mingw_xopen(const char *filename, int oflags);
+ssize_t mingw_open_read_close(const char *fn, void *buf, size_t size) FAST_FUNC;
+
+#ifndef IO_REPARSE_TAG_APPEXECLINK
+# define IO_REPARSE_TAG_APPEXECLINK 0x8000001b
+#endif
+
+ssize_t mingw_read(int fd, void *buf, size_t count);
+int mingw_close(int fd);
+int pipe(int filedes[2]);
+NOIMPL(setgid,gid_t gid UNUSED_PARAM);
+NOIMPL(setegid,gid_t gid UNUSED_PARAM);
+NOIMPL(setsid,void);
+NOIMPL(setuid,uid_t gid UNUSED_PARAM);
+NOIMPL(seteuid,uid_t gid UNUSED_PARAM);
+unsigned int sleep(unsigned int seconds);
+int symlink(const char *target, const char *linkpath);
+int create_junction(const char *oldpath, const char *newpath);
+long sysconf(int name);
+IMPL(getpagesize,int,4096,void);
+NOIMPL(ttyname_r,int fd UNUSED_PARAM, char *buf UNUSED_PARAM, int sz UNUSED_PARAM);
+int mingw_unlink(const char *pathname);
+int mingw_access(const char *name, int mode);
+int mingw_rmdir(const char *name);
+void mingw_sync(void);
+int mingw_isatty(int fd);
+
+#define dup2 mingw_dup2
+#define getcwd mingw_getcwd
+#define lchown chown
+#define open mingw_open
+#define close mingw_close
+#define unlink mingw_unlink
+#define rmdir mingw_rmdir
+#define sync mingw_sync
+#undef lseek
+#define lseek mingw_lseek
+
+#undef access
+#define access mingw_access
+#define isatty mingw_isatty
+
+/*
+ * utime.h
+ */
+int utimes(const char *file_name, const struct timeval times[2]);
+
+/*
+ * Functions with different prototypes in BusyBox and WIN32
+ */
+#define itoa bb_itoa
+#define strrev bb_strrev
+
+/*
+ * MinGW specific
+ */
+#define is_dir_sep(c) ((c) == '/' || (c) == '\\')
+#define is_unc_path(x) (strlen(x) > 4 && is_dir_sep(x[0]) && \
+                                                        is_dir_sep(x[1]) && !is_dir_sep(x[2]))
+
+typedef struct {
+        char *path;
+        char *name;
+        char *opts;
+        char buf[100];
+} interp_t;
+
+int FAST_FUNC parse_interpreter(const char *cmd, interp_t *interp);
+char ** FAST_FUNC grow_argv(char **argv, int n);
+pid_t FAST_FUNC mingw_spawn(char **argv);
+intptr_t FAST_FUNC mingw_spawn_detach(char **argv);
+intptr_t FAST_FUNC mingw_spawn_proc(const char **argv);
+int mingw_execv(const char *cmd, char *const *argv);
+int httpd_execv_detach(const char *cmd, char *const *argv);
+int mingw_execvp(const char *cmd, char *const *argv);
+int mingw_execve(const char *cmd, char *const *argv, char *const *envp);
+#define spawn mingw_spawn
+#define execvp mingw_execvp
+#define execve mingw_execve
+#define execv mingw_execv
+#define HTTPD_DETACH (8)
+
+#define has_dos_drive_prefix(path) (isalpha(*(path)) && (path)[1] == ':')
+
+BOOL WINAPI kill_child_ctrl_handler(DWORD dwCtrlType);
+int FAST_FUNC is_valid_signal(int number);
+int exit_code_to_wait_status(DWORD win_exit_code);
+int exit_code_to_posix(DWORD win_exit_code);
+
+#define find_mount_point(n, s) find_mount_point(n)
+
+char *is_prefixed_with_case(const char *string, const char *key) FAST_FUNC;
+char *is_suffixed_with_case(const char *string, const char *key) FAST_FUNC;
+
+#define VT_OUTPUT       1
+#define VT_INPUT        2
+
+/*
+ * helpers
+ */
+
+const char *get_busybox_exec_path(void);
+void init_winsock(void);
+
+int has_bat_suffix(const char *p);
+int has_exe_suffix(const char *p);
+int has_exe_suffix_or_dot(const char *name);
+char *alloc_ext_space(const char *path);
+int add_win32_extension(char *p);
+char *file_is_win32_exe(const char *name);
+
+#if ENABLE_UNICODE_SUPPORT
+/*
+ * windows wchar_t is 16 bit, while linux (and busybox expectation) is 32.
+ * so when (busybox) unicode.h is included, wchar_t is 32 bit.
+ * Without unicode.h, MINGW_BB_WCHAR_T is busybox wide char (32),
+ * and wchar_t is Windows wide char (16).
+ */
+#define MINGW_BB_WCHAR_T uint32_t  /* keep in sync with unicode.h */
+
+MINGW_BB_WCHAR_T *bs_to_slash_u(MINGW_BB_WCHAR_T *p) FAST_FUNC;
+#endif
+
+char *bs_to_slash(char *p) FAST_FUNC;
+void slash_to_bs(char *p) FAST_FUNC;
+void strip_dot_space(char *p) FAST_FUNC;
+size_t remove_cr(char *p, size_t len) FAST_FUNC;
+
+int err_win_to_posix(void);
+
+ULONGLONG CompatGetTickCount64(void);
+#define GetTickCount64 CompatGetTickCount64
+
+ssize_t get_random_bytes(void *buf, ssize_t count);
+int enumerate_links(const char *file, char *name);
+
+int unc_root_len(const char *dir) FAST_FUNC;
+int root_len(const char *path) FAST_FUNC;
+const char *get_system_drive(void) FAST_FUNC;
+int chdir_system_drive(void);
+char *xabsolute_path(char *path) FAST_FUNC;
+char *get_drive_cwd(const char *path, char *buffer, int size) FAST_FUNC;
+void fix_path_case(char *path) FAST_FUNC;
+void make_sparse(int fd, off_t start, off_t end) FAST_FUNC;
+int terminal_mode(int reset) FAST_FUNC;
+int unix_path(const char *path) FAST_FUNC;
+int has_path(const char *file) FAST_FUNC;
+int is_relative_path(const char *path) FAST_FUNC;
+char *get_last_slash(const char *path) FAST_FUNC;
+const char *applet_to_exe(const char *name) FAST_FUNC;
+char *get_user_name(void);
+char *quote_arg(const char *arg) FAST_FUNC;
+char *find_first_executable(const char *name) FAST_FUNC;
+char *xappendword(const char *str, const char *word) FAST_FUNC;
+int windows_env(void);
+void change_critical_error_dialogs(const char *newval) FAST_FUNC;
+char *exe_relative_path(const char *tail) FAST_FUNC;
+enum {
+        ELEVATED_PRIVILEGE = 1,
+        ADMIN_ENABLED = 2
+};
+int elevation_state(void);
+void set_interp(int i) FAST_FUNC;
+int mingw_shell_execute(SHELLEXECUTEINFO *info);
+void mingw_die_if_error(NTSTATUS status, const char *function_name);
diff --git a/include/platform.h b/include/platform.h
index ea0512f36..0b88f990b 100644
--- a/include/platform.h
+++ b/include/platform.h
@@ -7,6 +7,20 @@
 #ifndef BB_PLATFORM_H
 #define BB_PLATFORM_H 1
 
+#if ENABLE_PLATFORM_MINGW32
+# if !defined(__MINGW32__) /* HOSTCC is called */
+#  undef ENABLE_PLATFORM_MINGW32
+# else
+#  undef __USE_MINGW_ANSI_STDIO
+#  define __USE_MINGW_ANSI_STDIO 0
+#  undef _WIN32_WINNT
+#  define _WIN32_WINNT 0x502
+# endif
+#else
+# if defined(__MINGW32__)
+#  error "You must select target platform MS Windows, or it won't build"
+# endif
+#endif
 
 /* Convenience macros to test the version of gcc. */
 #undef __GNUC_PREREQ
@@ -135,7 +149,7 @@
 
 /* Make all declarations hidden (-fvisibility flag only affects definitions) */
 /* (don't include system headers after this until corresponding pop!) */
-#if __GNUC_PREREQ(4,1) && !defined(__CYGWIN__)
+#if __GNUC_PREREQ(4,1) && !defined(__CYGWIN__) && !ENABLE_PLATFORM_MINGW32
 # define PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN _Pragma("GCC visibility push(hidden)")
 # define POP_SAVED_FUNCTION_VISIBILITY              _Pragma("GCC visibility pop")
 #else
@@ -164,6 +178,13 @@
 # define bswap_64 __bswap64
 # define bswap_32 __bswap32
 # define bswap_16 __bswap16
+#elif ENABLE_PLATFORM_MINGW32
+# define __BIG_ENDIAN 0
+# define __LITTLE_ENDIAN 1
+# define __BYTE_ORDER __LITTLE_ENDIAN
+# define bswap_16(x) ((((x) & 0xFF00) >> 8) | (((x) & 0xFF) << 8))
+# define bswap_32(x) ((bswap_16(((x) & 0xFFFF0000L) >> 16)) | (bswap_16((x) & 0xFFFFL) << 16))
+# define bswap_64(x) ((bswap_32(((x) & 0xFFFFFFFF00000000LL) >> 32)) | (bswap_32((x) & 0xFFFFFFFFLL) << 32))
 #else
 # include <byteswap.h>
 # include <endian.h>
@@ -187,7 +208,7 @@
 #elif defined(BYTE_ORDER) && BYTE_ORDER == LITTLE_ENDIAN
 # define BB_BIG_ENDIAN 0
 # define BB_LITTLE_ENDIAN 1
-#elif defined(__386__)
+#elif defined(__i386__)
 # define BB_BIG_ENDIAN 0
 # define BB_LITTLE_ENDIAN 1
 #else
@@ -443,6 +464,26 @@ typedef unsigned smalluint;
 # endif
 #endif
 
+#if ENABLE_PLATFORM_MINGW32
+# undef HAVE_FDATASYNC
+# undef HAVE_DPRINTF
+# undef HAVE_GETLINE
+# undef HAVE_MEMRCHR
+# undef HAVE_MKDTEMP
+# undef HAVE_SETBIT
+# undef HAVE_STPCPY
+# undef HAVE_STPNCPY
+# undef HAVE_STRCASESTR
+# undef HAVE_STRCHRNUL
+# undef HAVE_STRSEP
+#if !defined(__MINGW64_VERSION_MAJOR)
+# undef HAVE_VASPRINTF
+#endif
+# undef HAVE_UNLOCKED_STDIO
+# undef HAVE_UNLOCKED_LINE_OPS
+# undef HAVE_PRINTF_PERCENTM
+#endif
+
 #if defined(__WATCOMC__)
 # undef HAVE_DPRINTF
 # undef HAVE_GETLINE
@@ -563,6 +604,7 @@ extern int dprintf(int fd, const char *format, ...);
 #endif
 
 #ifndef HAVE_MEMRCHR
+#include <stddef.h>
 extern void *memrchr(const void *s, int c, size_t n) FAST_FUNC;
 #endif
 
@@ -626,6 +668,7 @@ extern int usleep(unsigned) FAST_FUNC;
 #endif
 
 #ifndef HAVE_VASPRINTF
+# include <stdarg.h>
 extern int vasprintf(char **string_ptr, const char *format, va_list p) FAST_FUNC;
 #endif
 
diff --git a/include/unicode.h b/include/unicode.h
index 0317a2151..cdf35acb7 100644
--- a/include/unicode.h
+++ b/include/unicode.h
@@ -33,7 +33,11 @@ enum {
 
 # if CONFIG_LAST_SUPPORTED_WCHAR < 126 || CONFIG_LAST_SUPPORTED_WCHAR >= 0x30000
 #  undef CONFIG_LAST_SUPPORTED_WCHAR
+#  if ENABLE_PLATFORM_MINGW32
+#  define CONFIG_LAST_SUPPORTED_WCHAR 0x10ffff  /* full unicode range */
+#  else
 #  define CONFIG_LAST_SUPPORTED_WCHAR 0x2ffff
+#  endif
 # endif
 
 # if CONFIG_LAST_SUPPORTED_WCHAR < 0x300
@@ -87,6 +91,21 @@ void reinit_unicode(const char *LANG) FAST_FUNC;
 #  undef MB_CUR_MAX
 #  define MB_CUR_MAX 6
 
+#if ENABLE_PLATFORM_MINGW32
+  #undef wint_t
+  #undef mbstate_t
+  #undef mbstowcs
+  #undef wcstombs
+  #undef wcrtomb
+  #undef iswspace
+  #undef iswalnum
+  #undef iswpunct
+  #undef wcwidth
+
+  #undef wchar_t
+  #define wchar_t uint32_t  /* keep in sync with MINGW_BB_WCHAR_T */
+#endif
+
 /* Prevent name collisions */
 #  define wint_t    bb_wint_t
 #  define mbstate_t bb_mbstate_t
diff --git a/include/usage.src.h b/include/usage.src.h
index 5d2038834..0881337f8 100644
--- a/include/usage.src.h
+++ b/include/usage.src.h
@@ -17,11 +17,11 @@
 #define scripted_trivial_usage NOUSAGE_STR
 #define scripted_full_usage ""
 
-#if !ENABLE_USE_BB_CRYPT || ENABLE_USE_BB_CRYPT_SHA
-# define CRYPT_METHODS_HELP_STR "des,md5,sha256/512" \
+#if !ENABLE_USE_BB_CRYPT
+# define CRYPT_METHODS_HELP_STR "des,md5,sha256/512,yescrypt" \
         " (default "CONFIG_FEATURE_DEFAULT_PASSWD_ALGO")"
 #else
-# define CRYPT_METHODS_HELP_STR "des,md5" \
+# define CRYPT_METHODS_HELP_STR "des,md5"IF_USE_BB_CRYPT_SHA(",sha256/512")IF_USE_BB_CRYPT_YES(",yescrypt") \
         " (default "CONFIG_FEATURE_DEFAULT_PASSWD_ALGO")"
 #endif