From b80d279b287851ebbc92f56b3f41948dfd162d25 Mon Sep 17 00:00:00 2001
From: Corinna Vinschen <corinna@vinschen.de>
Date: Tue, 15 Jul 2025 09:29:24 +0200
Subject: [PATCH 01/84] Cygwin: bump DLL version to 3.6.5

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>
---
 winsup/cygwin/include/cygwin/version.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/winsup/cygwin/include/cygwin/version.h b/winsup/cygwin/include/cygwin/version.h
index 89c1e1fa16..69c19f535b 100644
--- a/winsup/cygwin/include/cygwin/version.h
+++ b/winsup/cygwin/include/cygwin/version.h
@@ -11,7 +11,7 @@ details. */
    changes to the DLL and is mainly informative in nature. */
 
 #define CYGWIN_VERSION_DLL_MAJOR 3006
-#define CYGWIN_VERSION_DLL_MINOR 4
+#define CYGWIN_VERSION_DLL_MINOR 5
 
 /* CYGWIN_VERSION_DLL_COMBINED gives us a single number representing the
    combined DLL major and minor numbers. */

From 7c8e7f92e3ce85de1fe966ad9bba8307df796e94 Mon Sep 17 00:00:00 2001
From: Corinna Vinschen <corinna@vinschen.de>
Date: Wed, 16 Jul 2025 11:26:15 +0200
Subject: [PATCH 02/84] Cygwin: clocks: use InterlockedCompareExchange64

The clock init functions checked timer ticks/period for 0 and then
called InterlockedExchange64 if the value was still 0.  This is not
quite as atomic as it was supposed to be.

Use InterlockedCompareExchange64 instead.

Fixes: 2b72887ac834b ("Cygwin: clocks: fix a hang on pre-Windows 10 machines")
Signed-off-by: Corinna Vinschen <corinna@vinschen.de>
(cherry picked from commit 167ace9a6d9605f67cd52369dd1e7758ec0d0af5)
---
 winsup/cygwin/clock.cc | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/winsup/cygwin/clock.cc b/winsup/cygwin/clock.cc
index 2a4e86922b..dc940906ed 100644
--- a/winsup/cygwin/clock.cc
+++ b/winsup/cygwin/clock.cc
@@ -32,22 +32,19 @@ system_tickcount_period ()
 void inline
 clk_t::init ()
 {
-  if (!period)
-    InterlockedExchange64 (&period, system_tickcount_period ());
+  InterlockedCompareExchange64 (&period, system_tickcount_period (), 0);
 }
 
 void inline
 clk_realtime_t::init ()
 {
-  if (!ticks_per_sec)
-    InterlockedExchange64 (&ticks_per_sec, system_qpc_tickspersec ());
+  InterlockedCompareExchange64 (&ticks_per_sec, system_qpc_tickspersec (), 0);
 }
 
 void inline
 clk_monotonic_t::init ()
 {
-  if (!ticks_per_sec)
-    InterlockedExchange64 (&ticks_per_sec, system_qpc_tickspersec ());
+  InterlockedCompareExchange64 (&ticks_per_sec, system_qpc_tickspersec (), 0);
 }
 
 int

From 3b1d436c22a99c4230f1fff38cdc9adef21e417c Mon Sep 17 00:00:00 2001
From: Corinna Vinschen <corinna@vinschen.de>
Date: Wed, 16 Jul 2025 11:46:02 +0200
Subject: [PATCH 03/84] Cygwin: POSIX timer: handle TIMER_ABSTIME correctly for
 all realtime clocks

Add CLOCK_REALTIME_COARSE and CLOCK_REALTIME_ALARM to the clocks
allowing an absolute timeout value to be used as such in NtSetTimer.

Fixes: c05df02725c59 ("Cygwin: implement extensible clock interface")
Fixes: 013e2bd9ecf85 ("Cygwin: posix timers: Add support for CLOCK_REALTIME_ALARM/CLOCK_BOOTTIME_ALARM")
Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

(cherry picked from commit 2e8c180a837e83e2a37ee68e6b38b40462d5c5d2)
---
 winsup/cygwin/posix_timer.cc | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/winsup/cygwin/posix_timer.cc b/winsup/cygwin/posix_timer.cc
index a336b2bc2d..14694a87dd 100644
--- a/winsup/cygwin/posix_timer.cc
+++ b/winsup/cygwin/posix_timer.cc
@@ -349,7 +349,9 @@ timer_tracker::settime (int flags, const itimerspec *new_value,
 		 / (NSPERSEC / NS100PERSEC);
 	  if (flags & TIMER_ABSTIME)
 	    {
-	      if (clock_id == CLOCK_REALTIME)
+	      if (clock_id == CLOCK_REALTIME_COARSE
+		  || clock_id == CLOCK_REALTIME
+		  || clock_id == CLOCK_REALTIME_ALARM)
 		DueTime.QuadPart = ts + FACTOR;
 	      else /* non-REALTIME clocks require relative DueTime. */
 		{

From e3470cf9907815ec1d32c8feb5122d0aafee029d Mon Sep 17 00:00:00 2001
From: Corinna Vinschen <corinna@vinschen.de>
Date: Wed, 16 Jul 2025 12:12:05 +0200
Subject: [PATCH 04/84] Cygwin: add clock bugfixes to 3.6.5 release message

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>
(cherry picked from commit 554173db31ec7dbf32b32c5d9854e4e8ea68eb7f)
---
 winsup/cygwin/release/3.6.5 | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 winsup/cygwin/release/3.6.5

diff --git a/winsup/cygwin/release/3.6.5 b/winsup/cygwin/release/3.6.5
new file mode 100644
index 0000000000..471a12a916
--- /dev/null
+++ b/winsup/cygwin/release/3.6.5
@@ -0,0 +1,4 @@
+Fixes:
+------
+
+Fix two minor bugs in clock and POSIX timer handling.

From 5fb125d018b00d0a4ece4d1f2be7c5e60f8280f0 Mon Sep 17 00:00:00 2001
From: Takashi Yano <takashi.yano@nifty.ne.jp>
Date: Wed, 16 Jul 2025 23:21:17 +0900
Subject: [PATCH 05/84] newlib: fclose: Use sfp lock while fp lock is active

With the commit 656df313e08a, if a thread acquires sfp lock after
another thread calls fclose() and fp lock is acquired, the first
thread falls into deadlock if it tries to acquire fp lock. This can
happen if the first thread calls __sfp_lock_all() while the second
thread calls fclose().

This patch reverts the changes for newlib/libc/stdio/fclose.c in
the commit 656df313e08a.

Addresses: https://cygwin.com/pipermail/cygwin/2025-June/258323.html
Fixes: 656df313e08a ("* libc/stdio/fclose.c: Only use sfp lock to guard non-atomic changes of flags and fp lock.")
Reported-by: Takashi Yano <takashi.yano@nifty.ne.jp>
Reviewed-by: Corinna Vinschen <corinna@vinschen.de>
Signed-off-by: Takashi Yano <takashi.yano@nifty.ne.jp>
(cherry picked from commit e8bc312a2d32a465260e38f948d91f2847a1d00a)
---
 newlib/libc/stdio/fclose.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/newlib/libc/stdio/fclose.c b/newlib/libc/stdio/fclose.c
index 983ae2cc40..4c81cbf4b7 100644
--- a/newlib/libc/stdio/fclose.c
+++ b/newlib/libc/stdio/fclose.c
@@ -72,6 +72,7 @@ _fclose_r (struct _reent *rptr,
   int __oldcancel;
   pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &__oldcancel);
 #endif
+  __sfp_lock_acquire ();
   if (!(fp->_flags2 & __SNLK))
     _flockfile (fp);
 
@@ -79,6 +80,7 @@ _fclose_r (struct _reent *rptr,
     {
       if (!(fp->_flags2 & __SNLK))
 	_funlockfile (fp);
+      __sfp_lock_release ();
 #ifdef _STDIO_WITH_THREAD_CANCELLATION_SUPPORT
       pthread_setcancelstate (__oldcancel, &__oldcancel);
 #endif
@@ -101,7 +103,6 @@ _fclose_r (struct _reent *rptr,
     FREEUB (rptr, fp);
   if (HASLB (fp))
     FREELB (rptr, fp);
-  __sfp_lock_acquire ();
   fp->_flags = 0;		/* release this FILE for reuse */
   if (!(fp->_flags2 & __SNLK))
     _funlockfile (fp);

From d0d90851f1285478739e0b63a098c02eb5c7d51f Mon Sep 17 00:00:00 2001
From: Corinna Vinschen <corinna@vinschen.de>
Date: Fri, 18 Jul 2025 10:15:30 +0200
Subject: [PATCH 06/84] Cygwin: sys/termios.h: define struct winsize before
 using it
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Long-standing bug in the sys/termios.h file which, for some reason,
has never been encountered before.

STC:

  #include <sys/termios.h>

  int main()
  {
    struct winsize win;
    tcgetwinsize (0, &win);
  }

Result with gcc 12.4.0:

  termios-bug.c: In function ‘main’:
  termios-bug.c:7:20: warning: passing argument 2 of ‘tcgetwinsize’ from incompatible pointer type [-Wincompatible-pointer-types]
      7 |   tcgetwinsize (0, &win);
	|                    ^~~~
	|                    |
	|                    struct winsize *
  In file included from termios-bug.c:1:
  /usr/include/sys/termios.h:304:42: note: expected ‘struct winsize *’ but argument is of type ‘struct winsize *’
    304 | int tcgetwinsize(int fd, struct winsize *winsz);
	|                          ~~~~~~~~~~~~~~~~^~~~~

This warning apparently becomes an error with C23.

The reason is that struct winsize is defined in sys/termios.h after
using it as argument type in function declarations.  From the compil;er
perspective it's now a different type , regardless of having the same
name.

Move declaration of struct winsize up so it's defined before being used.

Reported-by: Zachary Santer <zsanter@gmail.com>
Suggested-by: Zachary Santer <zsanter@gmail.com>
Addresses: https://cygwin.com/pipermail/cygwin/2025-July/258474.html
Fixes: 1fd5e000ace55 ("import winsup-2000-02-17 snapshot")
Signed-off-by: Corinna Vinschen <corinna@vinschen.de>
(cherry picked from commit 73600d68227e125af24b7de7c3fccbd4eb66ee03)
---
 winsup/cygwin/include/sys/termios.h | 13 ++++++-------
 winsup/cygwin/release/3.6.5         |  5 ++++-
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/winsup/cygwin/include/sys/termios.h b/winsup/cygwin/include/sys/termios.h
index d1b4a0af5b..75e0c53482 100644
--- a/winsup/cygwin/include/sys/termios.h
+++ b/winsup/cygwin/include/sys/termios.h
@@ -282,6 +282,12 @@ struct termios
   speed_t	c_ospeed;
 };
 
+struct winsize
+{
+  unsigned short ws_row, ws_col;
+  unsigned short ws_xpixel, ws_ypixel;
+};
+
 #define termio termios
 
 #ifdef __cplusplus
@@ -313,13 +319,6 @@ int tcsetwinsize(int fd, const struct winsize *winsz);
 #define cfgetospeed(tp)		((tp)->c_ospeed)
 #endif
 
-/* Extra stuff to make porting stuff easier.  */
-struct winsize
-{
-  unsigned short ws_row, ws_col;
-  unsigned short ws_xpixel, ws_ypixel;
-};
-
 #define TIOCGWINSZ (('T' << 8) | 1)
 #define TIOCSWINSZ (('T' << 8) | 2)
 #define TIOCLINUX  (('T' << 8) | 3)
diff --git a/winsup/cygwin/release/3.6.5 b/winsup/cygwin/release/3.6.5
index 471a12a916..402c8abaee 100644
--- a/winsup/cygwin/release/3.6.5
+++ b/winsup/cygwin/release/3.6.5
@@ -1,4 +1,7 @@
 Fixes:
 ------
 
-Fix two minor bugs in clock and POSIX timer handling.
+- Fix two minor bugs in clock and POSIX timer handling.
+
+- Fix an ordering problem in sys/termios.h.
+  Addresses: https://cygwin.com/pipermail/cygwin/2025-July/258474.html

From d62ac25ff4eebf117bad1982464cff4d439947b6 Mon Sep 17 00:00:00 2001
From: Takashi Yano <takashi.yano@nifty.ne.jp>
Date: Sat, 19 Jul 2025 23:39:12 +0900
Subject: [PATCH 07/84] Cygwin: cygheap: Add lock()/unlock() method

...so that cygheap can be locked/unlocked from outside of mm/cygheap.cc.

Reviewed-by: Corinna Vinschen <corinna@vinschen.de>
Signed-off-by: Takashi Yano <takashi.yano@nifty.ne.jp>
(cherry picked from commit aec6dc77a11b264fcac73b63ada701854fc62a22)
---
 winsup/cygwin/local_includes/cygheap.h |  5 +++++
 winsup/cygwin/mm/cygheap.cc            | 12 ++++++------
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/winsup/cygwin/local_includes/cygheap.h b/winsup/cygwin/local_includes/cygheap.h
index fed87ec2b6..d9e936c1e4 100644
--- a/winsup/cygwin/local_includes/cygheap.h
+++ b/winsup/cygwin/local_includes/cygheap.h
@@ -498,6 +498,9 @@ struct threadlist_t
 
 struct init_cygheap: public mini_cygheap
 {
+private:
+  static SRWLOCK cygheap_protect;
+public:
   _cmalloc_entry *chain;
   char *buckets[NBUCKETS];
   UNICODE_STRING installation_root;
@@ -541,6 +544,8 @@ struct init_cygheap: public mini_cygheap
   threadlist_t *find_tls (int, bool&);
   sigset_t compute_sigblkmask ();
   void unlock_tls (threadlist_t *t) { if (t) ReleaseMutex (t->mutex); }
+  inline void lock () { AcquireSRWLockExclusive (&cygheap_protect); }
+  inline void unlock () { ReleaseSRWLockExclusive (&cygheap_protect); }
 };
 
 
diff --git a/winsup/cygwin/mm/cygheap.cc b/winsup/cygwin/mm/cygheap.cc
index 3388864688..1c9b8037b2 100644
--- a/winsup/cygwin/mm/cygheap.cc
+++ b/winsup/cygwin/mm/cygheap.cc
@@ -35,7 +35,7 @@ static mini_cygheap NO_COPY cygheap_dummy =
 init_cygheap NO_COPY *cygheap = (init_cygheap *) &cygheap_dummy;
 void NO_COPY *cygheap_max;
 
-static NO_COPY SRWLOCK cygheap_protect = SRWLOCK_INIT;
+SRWLOCK NO_COPY init_cygheap::cygheap_protect = SRWLOCK_INIT;
 
 struct cygheap_entry
 {
@@ -367,7 +367,7 @@ _cmalloc (unsigned size)
   if (b >= NBUCKETS)
     return NULL;
 
-  AcquireSRWLockExclusive (&cygheap_protect);
+  cygheap->lock ();
   if (cygheap->buckets[b])
     {
       rvc = (_cmalloc_entry *) cygheap->buckets[b];
@@ -379,7 +379,7 @@ _cmalloc (unsigned size)
       rvc = (_cmalloc_entry *) _csbrk (bucket_val[b] + sizeof (_cmalloc_entry));
       if (!rvc)
 	{
-	  ReleaseSRWLockExclusive (&cygheap_protect);
+	  cygheap->unlock ();
 	  return NULL;
 	}
 
@@ -387,19 +387,19 @@ _cmalloc (unsigned size)
       rvc->prev = cygheap->chain;
       cygheap->chain = rvc;
     }
-  ReleaseSRWLockExclusive (&cygheap_protect);
+  cygheap->unlock ();
   return rvc->data;
 }
 
 static void
 _cfree (void *ptr)
 {
-  AcquireSRWLockExclusive (&cygheap_protect);
+  cygheap->lock ();
   _cmalloc_entry *rvc = to_cmalloc (ptr);
   unsigned b = rvc->b;
   rvc->ptr = cygheap->buckets[b];
   cygheap->buckets[b] = (char *) rvc;
-  ReleaseSRWLockExclusive (&cygheap_protect);
+  cygheap->unlock ();
 }
 
 static void *

From 5af6f6f2f3b18cb825513a1e8498016af7a2fc2e Mon Sep 17 00:00:00 2001
From: Takashi Yano <takashi.yano@nifty.ne.jp>
Date: Sat, 19 Jul 2025 23:39:12 +0900
Subject: [PATCH 08/84] Cygwin: spawn: Lock cygheap from refresh_cygheap()
 until child_copy()

...completion in child process because the cygheap should not be
changed to avoid mismatch between child_info::cygheap_max and
::cygheap_max. Otherwise, child_copy() might copy cygheap being
modified by other process.

In addition, to avoid deadlock, move close_all_files() for non-
Cygwin processes after unlocking cygheap, since close_all_files()
calls cfree(), which attempts to lock cygheap even when it's already
locked.

Fixes: 977ad5434cc0 ("* spawn.cc (spawn_guts): Call refresh_cygheap before creating a new process to ensure that cygheap_max is up-to-date.")
Reviewed-by: Corinna Vinschen <corinna@vinschen.de>
Signed-off-by: Takashi Yano <takashi.yano@nifty.ne.jp>
(cherry picked from commit 9b667234bfa6220dcca1afa1233a928d9100cfde)
---
 winsup/cygwin/spawn.cc | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/winsup/cygwin/spawn.cc b/winsup/cygwin/spawn.cc
index cb58b6eed0..7f2f5a8aa4 100644
--- a/winsup/cygwin/spawn.cc
+++ b/winsup/cygwin/spawn.cc
@@ -542,7 +542,6 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
 	::cygheap->ctty ? ::cygheap->ctty->tc_getpgid () : 0;
       if (!iscygwin () && ctty_pgid && ctty_pgid != myself->pgid)
 	c_flags |= CREATE_NEW_PROCESS_GROUP;
-      refresh_cygheap ();
 
       if (mode == _P_DETACH)
 	/* all set */;
@@ -611,6 +610,8 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
 
       cygpid = (mode != _P_OVERLAY) ? create_cygwin_pid () : myself->pid;
 
+      cygheap->lock ();
+      refresh_cygheap ();
       wchar_t wcmd[(size_t) cmd];
       if (!::cygheap->user.issetuid ()
 	  || (::cygheap->user.saved_uid == ::cygheap->user.real_uid
@@ -728,6 +729,7 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
 	    ::cygheap->user.reimpersonate ();
 
 	  res = -1;
+	  cygheap->unlock ();
 	  __leave;
 	}
 
@@ -764,8 +766,6 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
 	  NtClose (old_winpid_hdl);
 	  real_path.get_wide_win32_path (myself->progname); // FIXME: race?
 	  sigproc_printf ("new process name %W", myself->progname);
-	  if (!iscygwin ())
-	    close_all_files ();
 	}
       else
 	{
@@ -781,6 +781,7 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
 	      if (get_errno () != ENOMEM)
 		set_errno (EAGAIN);
 	      res = -1;
+	      cygheap->unlock ();
 	      __leave;
 	    }
 	  child->dwProcessId = pi.dwProcessId;
@@ -816,6 +817,7 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
 	      CloseHandle (pi.hProcess);
 	      ForceCloseHandle (pi.hThread);
 	      res = -1;
+	      cygheap->unlock ();
 	      __leave;
 	    }
 	}
@@ -844,6 +846,7 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
 	/* Just mark a non-cygwin process as 'synced'.  We will still eventually
 	   wait for it to exit in maybe_set_exit_code_from_windows(). */
 	synced = iscygwin () ? sync (pi.dwProcessId, pi.hProcess, INFINITE) : true;
+      cygheap->unlock ();
 
       switch (mode)
 	{
@@ -860,8 +863,7 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
 	    }
 	  else
 	    {
-	      if (iscygwin ())
-		close_all_files (true);
+	      close_all_files (iscygwin ());
 	      if (!my_wr_proc_pipe
 		  && WaitForSingleObject (pi.hProcess, 0) == WAIT_TIMEOUT)
 		wait_for_myself ();

From 94e4d32cfc89c8f4706451ba8bf212a1bbc335db Mon Sep 17 00:00:00 2001
From: Takashi Yano <takashi.yano@nifty.ne.jp>
Date: Sat, 19 Jul 2025 23:49:26 +0900
Subject: [PATCH 09/84] Cygwin: spawn: Make system() thread-safe

POSIX states system() shall be thread-safe, however, it is not in
current cygwin. This is because ch_spawn is a global and is shared
between threads. With this patch, system() uses ch_spawn_local
instead which is local variable. popen() has the same problem, so
it has been fixed in the same way.

Addresses: https://cygwin.com/pipermail/cygwin/2025-June/258324.html
Fixes: 1fd5e000ace5 ("import winsup-2000-02-17 snapshot")
Reported-by: Takashi Yano <takashi.yano@nifty.ne.jp>
Reviewed-by: Corinna Vinschen <corinna@vinschen.de>
Signed-off-by: Takashi Yano <takashi.yano@nifty.ne.jp>
(cherry picked from commit 1f836c5f7394ccde8b2f502d632ac8e07835586d)
---
 winsup/cygwin/spawn.cc    | 3 ++-
 winsup/cygwin/syscalls.cc | 5 +++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/winsup/cygwin/spawn.cc b/winsup/cygwin/spawn.cc
index 7f2f5a8aa4..680f0fefd5 100644
--- a/winsup/cygwin/spawn.cc
+++ b/winsup/cygwin/spawn.cc
@@ -950,6 +950,7 @@ spawnve (int mode, const char *path, const char *const *argv,
   if (!envp)
     envp = empty_env;
 
+  child_info_spawn ch_spawn_local (_CH_NADA, false);
   switch (_P_MODE (mode))
     {
     case _P_OVERLAY:
@@ -963,7 +964,7 @@ spawnve (int mode, const char *path, const char *const *argv,
     case _P_WAIT:
     case _P_DETACH:
     case _P_SYSTEM:
-      ret = ch_spawn.worker (path, argv, envp, mode);
+      ret = ch_spawn_local.worker (path, argv, envp, mode);
       break;
     default:
       set_errno (EINVAL);
diff --git a/winsup/cygwin/syscalls.cc b/winsup/cygwin/syscalls.cc
index d6a2c2d3b3..863f8f23c0 100644
--- a/winsup/cygwin/syscalls.cc
+++ b/winsup/cygwin/syscalls.cc
@@ -4535,8 +4535,9 @@ popen (const char *command, const char *in_type)
       fcntl (stdchild, F_SETFD, stdchild_state | FD_CLOEXEC);
 
       /* Start a shell process to run the given command without forking. */
-      pid_t pid = ch_spawn.worker ("/bin/sh", argv, environ, _P_NOWAIT,
-				   __std[0], __std[1]);
+      child_info_spawn ch_spawn_local (_CH_NADA, false);
+      pid_t pid = ch_spawn_local.worker ("/bin/sh", argv, environ, _P_NOWAIT,
+					 __std[0], __std[1]);
 
       /* Reinstate the close-on-exec state */
       fcntl (stdchild, F_SETFD, stdchild_state);

From 501be96044b53a5f1d43f3d3490cab373106dee7 Mon Sep 17 00:00:00 2001
From: Takashi Yano <takashi.yano@nifty.ne.jp>
Date: Wed, 23 Jul 2025 20:02:26 +0900
Subject: [PATCH 10/84] Cygwin: Add recent fixes to release note 3.6.5

(cherry picked from commit 9e0162a18d7db74f8692789bf726aa753540fb51)
---
 winsup/cygwin/release/3.6.5 | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/winsup/cygwin/release/3.6.5 b/winsup/cygwin/release/3.6.5
index 402c8abaee..3fbaa0c3a8 100644
--- a/winsup/cygwin/release/3.6.5
+++ b/winsup/cygwin/release/3.6.5
@@ -5,3 +5,10 @@ Fixes:
 
 - Fix an ordering problem in sys/termios.h.
   Addresses: https://cygwin.com/pipermail/cygwin/2025-July/258474.html
+
+- Fix doxygen hang due to a deadlock between fclose() and fork().
+  Addresses: https://cygwin.com/pipermail/cygwin-apps/2025-May/044318.html
+  Addresses: https://cygwin.com/pipermail/cygwin/2025-June/258323.html
+
+- Fix multi-thread safety of system().
+  Addresses: https://cygwin.com/pipermail/cygwin/2025-June/258324.html

From d9af4168292e01d4424eda5a403f575f67d920a6 Mon Sep 17 00:00:00 2001
From: Corinna Vinschen <corinna@vinschen.de>
Date: Tue, 22 Jul 2025 14:54:47 +0200
Subject: [PATCH 11/84] Revert "mbrtowc: fix handling invalid UTF-8 4 byte
 sequences if wchar_t == UTF-16"
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This reverts commit b374973d14ac7969b10ba719feedc709f6971c0d.

Turns out this patch breaks mbrtowc.  Example:

--- SNIP ---

void mb(unsigned char c)
{
  wchar_t wc;
  int ret = mbrtowc(&wc, &c, 1, 0);
  printf("%02X -> %04X : %d\n", c, wc, ret);
}

void main ()
{
  setlocale (LC_CTYPE, "");

  mb(0xF0);
  mb(0x9F);
  mb(0x98);
  mb(0x8E);
}
--- SNAP ---

Output before commit b374973d14ac:

F0 -> 0000 : -2
9F -> 0000 : -2
98 -> D83D : 1
8E -> DE0E : 1

Output after commit b374973d14ac:

F0 -> 0000 : -2
9F -> 0000 : -2
98 -> 0000 : -2
8E -> D83D : 3

By using mbrtowc(), the high surrogate is only emitted after byte 4, and
there's no way to recover the low surrogate.  The byte count is also incorrect.

Conclusion: We have to emit the high surrogate already after byte 3
to be able to emit the low surrogate after byte 4.

Reported-by: Thomas Wolff <towo@towo.net>
Addresses: https://cygwin.com/pipermail/cygwin/2025-July/258513.html
Fixes: b374973d14ac ("mbrtowc: fix handling invalid UTF-8 4 byte sequences if wchar_t == UTF-16")
Signed-off-by: Corinna Vinschen <corinna@vinschen.de>
(cherry picked from commit ba962ee04543855cfc6e2dc79a7369a78218815a)
---
 newlib/libc/stdlib/mbtowc_r.c | 25 +++++++++----------------
 1 file changed, 9 insertions(+), 16 deletions(-)

diff --git a/newlib/libc/stdlib/mbtowc_r.c b/newlib/libc/stdlib/mbtowc_r.c
index 6c3bd3d267..cab8333d70 100644
--- a/newlib/libc/stdlib/mbtowc_r.c
+++ b/newlib/libc/stdlib/mbtowc_r.c
@@ -677,21 +677,6 @@ __utf8_mbtowc (struct _reent *r,
 	state->__count = 3;
       else if (n < (size_t)-1)
 	++n;
-      if (n < 4)
-	return -2;
-      ch = t[i++];
-      if (ch < 0x80 || ch > 0xbf)
-	{
-	  _REENT_ERRNO(r) = EILSEQ;
-	  return -1;
-	}
-      /* Note: Originally we created the low surrogate pair on systems with
-	 wchar_t == UTF-16 *before* checking the 4th byte.  This was utterly
-	 wrong, because this failed to check the last byte for being a valid
-	 value for a complete UTF-8 4 byte sequence.  As a result, calling
-	 functions happily digested the low surrogate and then got an entirely
-	 different character and handled this separately, thus generating
-	 invalid UTF-16 values. */
       if (state->__count == 3 && sizeof(wchar_t) == 2)
 	{
 	  /* On systems which have wchar_t being UTF-16 values, the value
@@ -710,7 +695,15 @@ __utf8_mbtowc (struct _reent *r,
 	    |   (wint_t)((state->__value.__wchb[2] & 0x3f) << 6);
 	  state->__count = 4;
 	  *pwc = 0xd800 | ((tmp - 0x10000) >> 10);
-	  return 3;
+	  return i;
+	}
+      if (n < 4)
+	return -2;
+      ch = t[i++];
+      if (ch < 0x80 || ch > 0xbf)
+	{
+	  _REENT_ERRNO(r) = EILSEQ;
+	  return -1;
 	}
       tmp = (wint_t)((state->__value.__wchb[0] & 0x07) << 18)
 	|   (wint_t)((state->__value.__wchb[1] & 0x3f) << 12)

From 8a87d3501f63239ab24104a41fdb4a122dba2179 Mon Sep 17 00:00:00 2001
From: Corinna Vinschen <corinna@vinschen.de>
Date: Wed, 23 Jul 2025 22:42:01 +0200
Subject: [PATCH 12/84] Cygwin: _sys_mbstowcs: fix handling invalid 4-byte
 UTF-8 sequences

When a 4 byte utf-8 sequence has an invalid 4th byte, it's actually
an invalid 3 byte sequence.  In this case we already generated the
high surrogate and only realize the problem when byte 4 doesn't
match.

At this point _sys_mbstowcs transposes the invalid 4th byte into the
private use area.

This is wrong.  The invalid byte sequence here is the 3 byte sequence
already converted to a high surrogate, not the trailing 4th byte.

Fix this by backtracking to the start of the broken sequence and
overwrite the already written high surrogate with a sequence of
the original three bytes transposed to the private use area. Reset
the mbstate and restart normal conversion at the non-matching
4th byte, which might start a new multibyte sequence.

The resulting wide-char string can be converted back to multibyte
and back again to wide-char, and the result will be identical, even
if the multibyte sequence differs from the original sequence.

Fixes: e44b9069cd227 ("* strfuncs.cc (sys_cp_mbstowcs): Treat src as unsigned char *.  Convert failure of f_mbtowc into a single malformed utf-16 value.")
Signed-off-by: Corinna Vinschen <corinna@vinschen.de>
(cherry picked from commit 1463b41d403e861e4033387cdc71006e1664203a)
---
 winsup/cygwin/strfuncs.cc | 51 ++++++++++++++++++++++++++++++++++++---
 1 file changed, 47 insertions(+), 4 deletions(-)

diff --git a/winsup/cygwin/strfuncs.cc b/winsup/cygwin/strfuncs.cc
index cb7911c6b8..caaf6b7862 100644
--- a/winsup/cygwin/strfuncs.cc
+++ b/winsup/cygwin/strfuncs.cc
@@ -1071,6 +1071,7 @@ _sys_mbstowcs (mbtowc_p f_mbtowc, wchar_t *dst, size_t dlen, const char *src,
 {
   wchar_t *ptr = dst;
   unsigned const char *pmbs = (unsigned const char *) src;
+  unsigned const char *got_high_surrogate = NULL;
   size_t count = 0;
   size_t len = dlen;
   int bytes;
@@ -1142,16 +1143,58 @@ _sys_mbstowcs (mbtowc_p f_mbtowc, wchar_t *dst, size_t dlen, const char *src,
 
 	     Invalid bytes in a multibyte sequence are converted to
 	     the private use area which is already used to store ASCII
-	     chars invalid in Windows filenames.  This technque allows
+	     chars invalid in Windows filenames.  This technique allows
 	     to store them in a symmetric way. */
-	  bytes = 1;
-	  if (dst)
-	    *ptr = L'\xf000' | *pmbs;
+
+	  /* Special case high surrogate: if we already converted the first
+	     3 bytes of a sequence to a high surrogate, and only then encounter
+	     a non-matching forth byte, the sequence is simply cut short.  In
+	     that case not the currently handled 4th byte is the invalid
+	     sequence, but the 3 bytes converted to the high surrogate.  So we
+	     have to backtrack to the high surrogate and convert it to a
+	     sequence of bytes in the private use area.  Next, reset the
+	     mbstate and retry to convert starting at the current byte. */
+	  if (got_high_surrogate)
+	    {
+	      if (dst)
+		{
+		  --ptr;
+		  *ptr++ = L'\xf000' | *got_high_surrogate++;
+		  /* we know len > 0 at this point */
+		  *ptr++ = L'\xf000' | *got_high_surrogate++;
+		}
+	      --len;
+	      if (len > 0)
+		{
+		  if (dst)
+		    *ptr++ = L'\xf000' | *got_high_surrogate++;
+		  --len;
+		}
+	      count += 2; /* Actually 3, but we already counted one when
+			     generating the high surrogate. */
+	      memset (&ps, 0, sizeof ps);
+	      continue;
+	    }
+	  /* Never convert ASCII NUL */
+	  if (*pmbs)
+	    {
+	      bytes = 1;
+	      if (dst)
+		*ptr = L'\xf000' | *pmbs;
+	    }
 	  memset (&ps, 0, sizeof ps);
 	}
 
+      got_high_surrogate = NULL;
       if (bytes > 0)
 	{
+	  /* Check if we got the high surrogate from a UTF-8 4 byte sequence.
+	     This is used above to handle an invalid 4 byte sequence cut short
+	     at byte 3. */
+	  /* FIXME: do we need an equivalent check for gb18030? */
+	  if (bytes == 3 && ps.__count == 4 && f_mbtowc == __utf8_mbtowc)
+	    got_high_surrogate = pmbs;
+
 	  pmbs += bytes;
 	  nms -= bytes;
 	  ++count;

From 25ade6030b328d99f46836dac55f90878f5f4d8b Mon Sep 17 00:00:00 2001
From: Corinna Vinschen <corinna@vinschen.de>
Date: Wed, 23 Jul 2025 22:42:52 +0200
Subject: [PATCH 13/84] Cygwin: _sys_wcstombs: add FIXME comment

Add a FIXME comment to the conversion of private use area bytes to
"normal" bytes in _sys_wcstombs detailing the conversion difference
between _sys_wcstombs and standard wcstombs.  It might be a good idea
to drop the conversion to gather compatibility with wcstombs.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

(cherry picked from commit ada3b8f7e5a71db4881135380c407a86a08f6663)
---
 winsup/cygwin/strfuncs.cc | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/winsup/cygwin/strfuncs.cc b/winsup/cygwin/strfuncs.cc
index caaf6b7862..eb6576051d 100644
--- a/winsup/cygwin/strfuncs.cc
+++ b/winsup/cygwin/strfuncs.cc
@@ -965,8 +965,17 @@ _sys_wcstombs (char *dst, size_t len, const wchar_t *src, size_t nwc,
 
       /* Convert UNICODE private use area.  Reverse functionality for the
 	 ASCII area <= 0x7f (only for path names) is transform_chars above.
+
 	 Reverse functionality for invalid bytes in a multibyte sequence is
-	 in _sys_mbstowcs below. */
+	 in _sys_mbstowcs below.
+
+	 FIXME? The conversion of invalid bytes from the private use area
+	 like we do here is not actually necessary.  If we skip it, the
+	 generated multibyte string is not identical to the original multibyte
+	 string, but it's equivalent in the sense, that another mbstowcs will
+	 generate the same wide-char string.  It would also be identical to
+	 the same string converted by wcstombs.  And while the original
+	 multibyte string can't be converted by mbstowcs, this string can. */
       if (is_path && (pw & 0xff00) == 0xf000
 	  && (((cwc = (pw & 0xff)) <= 0x7f && tfx_rev_chars[cwc] >= 0xf000)
 	      || (cwc >= 0x80 && MB_CUR_MAX > 1)))

From 41e0d0e26e4584021c55d4dc9ba33fc957e08ef3 Mon Sep 17 00:00:00 2001
From: Corinna Vinschen <corinna@vinschen.de>
Date: Thu, 24 Jul 2025 11:24:32 +0200
Subject: [PATCH 14/84] Cygwin: Add UTF-8 surrogate fix to release messages

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>
(cherry picked from commit f21fbcaf583e1cadcbca9e094e269632bf0f2a9d)
---
 winsup/cygwin/release/3.6.5 | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/winsup/cygwin/release/3.6.5 b/winsup/cygwin/release/3.6.5
index 3fbaa0c3a8..97bb397926 100644
--- a/winsup/cygwin/release/3.6.5
+++ b/winsup/cygwin/release/3.6.5
@@ -12,3 +12,10 @@ Fixes:
 
 - Fix multi-thread safety of system().
   Addresses: https://cygwin.com/pipermail/cygwin/2025-June/258324.html
+
+- Revert fix handling of invalid 4 byte UTF-8 sequence. It was broken.
+  Addresses: https://cygwin.com/pipermail/cygwin/2025-July/258513.html
+
+- Instead, fix internal conversion of filenames in case of an invalid
+  4 byte UTF-8 sequence.
+  Addresses: https://cygwin.com/pipermail/cygwin/2025-June/258358.html

From 99cfcb824f30aebfd4a9a79f2ee698440f647ea4 Mon Sep 17 00:00:00 2001
From: Takashi Yano <takashi.yano@nifty.ne.jp>
Date: Thu, 24 Jul 2025 14:36:48 +0900
Subject: [PATCH 15/84] Cygwin: Fix handling of archetype fhandler in
 process_fd

Previously, process_fd failed to correctly handle fhandlers using an
archetype. This was due to the missing PATH_OPEN flag in path_conv,
which caused build_fh_pc() to skip archetype initialization. The
root cause was a bug where open() did not set the PATH_OPEN flag
for fhandlers using an archetype.

This patch introduces a new method, path_conv::set_isopen(), to
explicitly set the PATH_OPEN flag in path_flags in fhandler_base::
open_with_arch().

Addresses: https://cygwin.com/pipermail/cygwin/2025-May/258167.html
Fixes: 92ddb7429065 ("(build_pc_pc): Use fh_alloc to create. Set name from fh->dev if appropriate. Generate an archetype or point to one here.")
Reported-by: Christian Franke <Christian.Franke@t-online.de>
Reviewed-by: Corinna Vinschen <corinna@vinschen.de>
Signed-off-by: Takashi Yano <takashi.yano@nifty.ne.jp>
(cherry picked from commit f67a5cffe052b9e746f0baf64fb762e8b2de162d)
---
 winsup/cygwin/fhandler/base.cc      | 3 +++
 winsup/cygwin/local_includes/path.h | 1 +
 winsup/cygwin/release/3.6.5         | 3 +++
 3 files changed, 7 insertions(+)

diff --git a/winsup/cygwin/fhandler/base.cc b/winsup/cygwin/fhandler/base.cc
index 64a5f6aea8..beebd710c5 100644
--- a/winsup/cygwin/fhandler/base.cc
+++ b/winsup/cygwin/fhandler/base.cc
@@ -474,6 +474,9 @@ fhandler_base::open_with_arch (int flags, mode_t mode)
       if (!open_setup (flags))
 	api_fatal ("open_setup failed, %E");
     }
+  /* For pty and console, PATH_OPEN flag has not been set in open().
+     So set it here unconditionally. */
+  pc.set_isopen ();
 
   close_on_exec (flags & O_CLOEXEC);
   /* A unique ID is necessary to recognize fhandler entries which are
diff --git a/winsup/cygwin/local_includes/path.h b/winsup/cygwin/local_includes/path.h
index 1fd542c96b..a9ce2c7e4b 100644
--- a/winsup/cygwin/local_includes/path.h
+++ b/winsup/cygwin/local_includes/path.h
@@ -244,6 +244,7 @@ class path_conv
   int isopen () const {return path_flags & PATH_OPEN;}
   int isctty_capable () const {return path_flags & PATH_CTTY;}
   int follow_fd_symlink () const {return path_flags & PATH_RESOLVE_PROCFD;}
+  void set_isopen () {path_flags |= PATH_OPEN;}
   void set_cygexec (bool isset)
   {
     if (isset)
diff --git a/winsup/cygwin/release/3.6.5 b/winsup/cygwin/release/3.6.5
index 97bb397926..f14fbe6e1b 100644
--- a/winsup/cygwin/release/3.6.5
+++ b/winsup/cygwin/release/3.6.5
@@ -19,3 +19,6 @@ Fixes:
 - Instead, fix internal conversion of filenames in case of an invalid
   4 byte UTF-8 sequence.
   Addresses: https://cygwin.com/pipermail/cygwin/2025-June/258358.html
+
+- Make process_fd correctly handle pty and console.
+  Addresses: https://cygwin.com/pipermail/cygwin/2025-May/258167.html

From a5f96c196e71c7df4cac2575db7be97e95a39df4 Mon Sep 17 00:00:00 2001
From: Takashi Yano <takashi.yano@nifty.ne.jp>
Date: Sat, 16 Aug 2025 05:57:06 +0900
Subject: [PATCH 16/84] Cygwin: spawn: Make ch_spwan_local be initialized
 properly

The class child_info_spawn has two constructors: one without arguments
and one with two arguments. The former does not initialize any members.
Commit 1f836c5f7394 used the latter to ensure that the local ch_spawn
(i.e., ch_spawn_local) would be properly initialized. However, this was
insufficient - it initialized only the base child_info members, not the
fields specific to child_info_spawn. This led to the issue reported in
https://cygwin.com/pipermail/cygwin/2025-August/258660.html.

This patch introduces a new constructor to properly initialize member
variable 'ev', etc., which were referred without initialization, and
switches ch_spawn_local to use it. 'subproc_ready', which may not be
initialized, is also initialized in the constructor of the base class
child_info.

Addresses: https://cygwin.com/pipermail/cygwin/2025-August/258660.html
Fixes: 1f836c5f7394 ("Cygwin: spawn: Make system() thread-safe")
Reported-by: Denis Excoffier <cygwin@Denis-Excoffier.org>
Reviewed-by: Jeremy Drake <cygwin@jdrake.com>
Signed-off-by: Takashi Yano <takashi.yano@nifty.ne.jp>
(cherry picked from commit 880c96576b2423d1e77e25a3a2da7fc761377728)
---
 winsup/cygwin/local_includes/child_info.h | 3 ++-
 winsup/cygwin/sigproc.cc                  | 9 ++++++++-
 winsup/cygwin/spawn.cc                    | 2 +-
 winsup/cygwin/syscalls.cc                 | 2 +-
 4 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/winsup/cygwin/local_includes/child_info.h b/winsup/cygwin/local_includes/child_info.h
index 2da62ffaa3..25d99fa7de 100644
--- a/winsup/cygwin/local_includes/child_info.h
+++ b/winsup/cygwin/local_includes/child_info.h
@@ -33,7 +33,7 @@ enum child_status
 #define EXEC_MAGIC_SIZE sizeof(child_info)
 
 /* Change this value if you get a message indicating that it is out-of-sync. */
-#define CURR_CHILD_INFO_MAGIC 0xacbf4682U
+#define CURR_CHILD_INFO_MAGIC 0x77f25a01U
 
 #include "pinfo.h"
 struct cchildren
@@ -149,6 +149,7 @@ class child_info_spawn: public child_info
 
   void cleanup ();
   child_info_spawn () {};
+  child_info_spawn (child_info_types);
   child_info_spawn (child_info_types, bool);
   void record_children ();
   void reattach_children ();
diff --git a/winsup/cygwin/sigproc.cc b/winsup/cygwin/sigproc.cc
index 361887981b..30779cf8ed 100644
--- a/winsup/cygwin/sigproc.cc
+++ b/winsup/cygwin/sigproc.cc
@@ -895,7 +895,8 @@ child_info::child_info (unsigned in_cb, child_info_types chtype,
   msv_count (0), cb (in_cb), intro (PROC_MAGIC_GENERIC),
   magic (CHILD_INFO_MAGIC), type (chtype), cygheap (::cygheap),
   cygheap_max (::cygheap_max), flag (0), retry (child_info::retry_count),
-  rd_proc_pipe (NULL), wr_proc_pipe (NULL), sigmask (_my_tls.sigmask)
+  rd_proc_pipe (NULL), wr_proc_pipe (NULL), subproc_ready (NULL),
+  sigmask (_my_tls.sigmask)
 {
   fhandler_union_cb = sizeof (fhandler_union);
   user_h = cygwin_user_h;
@@ -946,6 +947,12 @@ child_info_fork::child_info_fork () :
 {
 }
 
+child_info_spawn::child_info_spawn (child_info_types chtype) :
+  child_info (sizeof *this, chtype, false), hExeced (NULL), ev (NULL),
+  sem (NULL), moreinfo (NULL)
+{
+}
+
 child_info_spawn::child_info_spawn (child_info_types chtype, bool need_subproc_ready) :
   child_info (sizeof *this, chtype, need_subproc_ready)
 {
diff --git a/winsup/cygwin/spawn.cc b/winsup/cygwin/spawn.cc
index 680f0fefd5..71add8755c 100644
--- a/winsup/cygwin/spawn.cc
+++ b/winsup/cygwin/spawn.cc
@@ -950,7 +950,7 @@ spawnve (int mode, const char *path, const char *const *argv,
   if (!envp)
     envp = empty_env;
 
-  child_info_spawn ch_spawn_local (_CH_NADA, false);
+  child_info_spawn ch_spawn_local (_CH_NADA);
   switch (_P_MODE (mode))
     {
     case _P_OVERLAY:
diff --git a/winsup/cygwin/syscalls.cc b/winsup/cygwin/syscalls.cc
index 863f8f23c0..1b1ff17b0a 100644
--- a/winsup/cygwin/syscalls.cc
+++ b/winsup/cygwin/syscalls.cc
@@ -4535,7 +4535,7 @@ popen (const char *command, const char *in_type)
       fcntl (stdchild, F_SETFD, stdchild_state | FD_CLOEXEC);
 
       /* Start a shell process to run the given command without forking. */
-      child_info_spawn ch_spawn_local (_CH_NADA, false);
+      child_info_spawn ch_spawn_local (_CH_NADA);
       pid_t pid = ch_spawn_local.worker ("/bin/sh", argv, environ, _P_NOWAIT,
 					 __std[0], __std[1]);
 

From 6285ae66744da6a2ed389b402eaa2bd3d74f4bc9 Mon Sep 17 00:00:00 2001
From: Takashi Yano <takashi.yano@nifty.ne.jp>
Date: Sat, 30 Aug 2025 11:39:39 +0900
Subject: [PATCH 17/84] Cygwin: pty: Fix FLUSHO handling

Previsouly, FLUSHO did not work correctly.
 1) Even when FLUSHO is set, read() returns with undesired data in
    the pipe if select() is called in advance.
 2) FLUSHO is toggled even in the case pseudo console enabled.
Due to these problems, read data in the pty master was partially
lost when Ctrl-O is pressed.

With this patch, the mask_flusho flag, that was introduced by the
commit 9677efcf005a and caused the issue 1), has been dropped and
select() and read() for pty master discards the pipe data instead
if FLUSHO flag is set.  In addition, FLUSHO handling in the case
pseudo console activated is disabled.

Addresses: https://cygwin.com/pipermail/cygwin/2025-August/258717.html
Fixes: 2cab4d0bb4af ("Cygwin: pty, console: Refactor the code processing special keys.")
Fixes: 9677efcf005a ("Cygwin: pty: Make FLUSHO and Ctrl-O work.")
Reported-by: Reported-by: Thomas Wolff <towo@towo.net>
Signed-off-by: Takashi Yano <takashi.yano@nifty.ne.jp>
(cherry picked from commit 7b5fb35e376cfab42335291008758a2a64ff66b1)
---
 winsup/cygwin/fhandler/pty.cc           |  6 +-----
 winsup/cygwin/local_includes/fhandler.h |  1 -
 winsup/cygwin/local_includes/tty.h      |  1 -
 winsup/cygwin/select.cc                 | 16 +++++++++++-----
 winsup/cygwin/tty.cc                    |  1 -
 5 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/winsup/cygwin/fhandler/pty.cc b/winsup/cygwin/fhandler/pty.cc
index 36fddbbe92..468bc3bc3f 100644
--- a/winsup/cygwin/fhandler/pty.cc
+++ b/winsup/cygwin/fhandler/pty.cc
@@ -693,8 +693,7 @@ fhandler_pty_master::process_slave_output (char *buf, size_t len, int pktmode_on
 
       termios_printf ("bytes read %u", n);
 
-      if (!buf || ((get_ttyp ()->ti.c_lflag & FLUSHO)
-		   && !get_ttyp ()->mask_flusho))
+      if (!buf || (get_ttyp ()->ti.c_lflag & FLUSHO))
 	continue; /* Discard read data */
 
       memcpy (optr, outbuf, n);
@@ -714,8 +713,6 @@ fhandler_pty_master::process_slave_output (char *buf, size_t len, int pktmode_on
     }
 
 out:
-  if (buf)
-    set_mask_flusho (false);
   termios_printf ("returning %d", rc);
   return rc;
 }
@@ -2240,7 +2237,6 @@ fhandler_pty_master::write (const void *ptr, size_t len)
 	      nlen--;
 	      i--;
 	    }
-	  process_stop_start (buf[i], get_ttyp ());
 	}
 
       DWORD n;
diff --git a/winsup/cygwin/local_includes/fhandler.h b/winsup/cygwin/local_includes/fhandler.h
index 94f4bc5521..5e8f3d30f3 100644
--- a/winsup/cygwin/local_includes/fhandler.h
+++ b/winsup/cygwin/local_includes/fhandler.h
@@ -2622,7 +2622,6 @@ class fhandler_pty_master: public fhandler_pty_common
   }
   void get_master_thread_param (master_thread_param_t *p);
   void get_master_fwd_thread_param (master_fwd_thread_param_t *p);
-  void set_mask_flusho (bool m) { get_ttyp ()->mask_flusho = m; }
   bool need_send_ctrl_c_event ();
 };
 
diff --git a/winsup/cygwin/local_includes/tty.h b/winsup/cygwin/local_includes/tty.h
index 2a047d73f9..754ee900e7 100644
--- a/winsup/cygwin/local_includes/tty.h
+++ b/winsup/cygwin/local_includes/tty.h
@@ -135,7 +135,6 @@ class tty: public tty_min
   bool master_is_running_as_service;
   bool req_xfer_input;
   xfer_dir pty_input_state;
-  bool mask_flusho;
   bool discard_input;
   bool stop_fwd_thread;
 
diff --git a/winsup/cygwin/select.cc b/winsup/cygwin/select.cc
index a7e82a0241..8a94ac0761 100644
--- a/winsup/cygwin/select.cc
+++ b/winsup/cygwin/select.cc
@@ -689,6 +689,8 @@ pipe_data_available (int fd, fhandler_base *fh, HANDLE h, int mode)
   return 0;
 }
 
+SRWLOCK ptym_peek_lock = SRWLOCK_INIT;
+
 static int
 peek_pipe (select_record *s, bool from_select)
 {
@@ -730,10 +732,19 @@ peek_pipe (select_record *s, bool from_select)
 	  gotone = s->read_ready = true;
 	  goto out;
 	}
+      if (fh->get_major () == DEV_PTYM_MAJOR)
+	AcquireSRWLockExclusive (&ptym_peek_lock);
       ssize_t n = pipe_data_available (s->fd, fh, h, PDA_READ);
       /* On PTY masters, check if input from the echo pipe is available. */
       if (n == 0 && fh->get_echo_handle ())
 	n = pipe_data_available (s->fd, fh, fh->get_echo_handle (), PDA_READ);
+      if (fh->get_major () == DEV_PTYM_MAJOR)
+	{
+	  fhandler_pty_master *fhm = (fhandler_pty_master *) fh;
+	  while (n > 0 && (fhm->tc ()->ti.c_lflag & FLUSHO))
+	    n = fhm->process_slave_output (NULL, n, 0); /* Discard pipe data */
+	  ReleaseSRWLockExclusive (&ptym_peek_lock);
+	}
 
       if (n == PDA_ERROR)
 	{
@@ -759,11 +770,6 @@ peek_pipe (select_record *s, bool from_select)
     }
 
 out:
-  if (fh->get_major () == DEV_PTYM_MAJOR)
-    {
-      fhandler_pty_master *fhm = (fhandler_pty_master *) fh;
-      fhm->set_mask_flusho (s->read_ready);
-    }
   h = fh->get_output_handle ();
   if (s->write_selected && dev != FH_PIPER)
     {
diff --git a/winsup/cygwin/tty.cc b/winsup/cygwin/tty.cc
index a4b7167217..0c49dc2bdf 100644
--- a/winsup/cygwin/tty.cc
+++ b/winsup/cygwin/tty.cc
@@ -253,7 +253,6 @@ tty::init ()
   req_xfer_input = false;
   pty_input_state = to_cyg;
   last_sig = 0;
-  mask_flusho = false;
   discard_input = false;
   stop_fwd_thread = false;
 }

From 822b49e97af9c6551911c0ff5297d31b61150e03 Mon Sep 17 00:00:00 2001
From: Takashi Yano <takashi.yano@nifty.ne.jp>
Date: Sat, 30 Aug 2025 12:08:21 +0900
Subject: [PATCH 18/84] Cygwin: Note Ctrl-O (FLUSHO) fix to release note

---
 winsup/cygwin/release/3.6.5 | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/winsup/cygwin/release/3.6.5 b/winsup/cygwin/release/3.6.5
index f14fbe6e1b..6a37b6a43f 100644
--- a/winsup/cygwin/release/3.6.5
+++ b/winsup/cygwin/release/3.6.5
@@ -22,3 +22,6 @@ Fixes:
 
 - Make process_fd correctly handle pty and console.
   Addresses: https://cygwin.com/pipermail/cygwin/2025-May/258167.html
+
+- Fix Ctrl-O (FLUSHO) handling.
+  Addresses: https://cygwin.com/pipermail/cygwin/2025-August/258717.html

From 275c91f518b9182c94bc33c2788d661f9b6e0a54 Mon Sep 17 00:00:00 2001
From: Jeremy Drake <cygwin@jdrake.com>
Date: Fri, 19 Sep 2025 13:36:30 -0700
Subject: [PATCH 19/84] Cygwin: lock cygheap during fork

another thread may simultaneously be doing a cmalloc/cfree while the
cygheap is being copied to the child.

Addresses: https://cygwin.com/pipermail/cygwin/2025-September/258801.html
Signed-off-by: Jeremy Drake <cygwin@jdrake.com>
(cherry picked from commit 8a5d39527f9a56d1a623e86d30af6b590fd1472d)
---
 winsup/cygwin/fork.cc       | 7 ++++++-
 winsup/cygwin/release/3.6.5 | 4 ++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/winsup/cygwin/fork.cc b/winsup/cygwin/fork.cc
index f88acdbbf7..2aa52737ca 100644
--- a/winsup/cygwin/fork.cc
+++ b/winsup/cygwin/fork.cc
@@ -329,6 +329,7 @@ frok::parent (volatile char * volatile stack_here)
   /* NEVER, EVER, call a function which in turn calls malloc&friends while this
      malloc lock is active! */
   __malloc_lock ();
+  cygheap->lock ();
   bool locked = true;
 
   /* Remove impersonation */
@@ -483,6 +484,7 @@ frok::parent (volatile char * volatile stack_here)
 		   impure, impure_beg, impure_end,
 		   NULL);
 
+  cygheap->unlock ();
   __malloc_unlock ();
   locked = false;
   if (!rc)
@@ -568,7 +570,10 @@ frok::parent (volatile char * volatile stack_here)
   if (fix_impersonation)
     cygheap->user.reimpersonate ();
   if (locked)
-    __malloc_unlock ();
+    {
+      cygheap->unlock ();
+      __malloc_unlock ();
+    }
 
   /* Remember to de-allocate the fd table. */
   if (hchild)
diff --git a/winsup/cygwin/release/3.6.5 b/winsup/cygwin/release/3.6.5
index 6a37b6a43f..d7cf8381f4 100644
--- a/winsup/cygwin/release/3.6.5
+++ b/winsup/cygwin/release/3.6.5
@@ -25,3 +25,7 @@ Fixes:
 
 - Fix Ctrl-O (FLUSHO) handling.
   Addresses: https://cygwin.com/pipermail/cygwin/2025-August/258717.html
+
+- Fix multi-thread safety of fork()/exec() by adding the same locking as was
+  done for spawn.
+  Addresses: https://cygwin.com/pipermail/cygwin/2025-September/258801.html

From 2ae6825d022ac4450cef168ce066d68810b3a6e2 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Mon, 6 Oct 2025 16:08:17 +0200
Subject: [PATCH 20/84] Cygwin: symlink_native: allow linking to `.` again

In 827743ab76 (Cygwin: symlink_native: allow linking to `..`,
2025-06-20), I fixed linking to `..` (which had inadvertently
targeted an incorrect location prior to that fix), but inadvertently
broke linking to `.` (which would now try to pass the empty string as
`lpTargetFileName` to `CreateSymbolicLinkW()`, failing with an
`ERROR_INVALID_REPARSE_DATA` which would be surfaced as "Permission
denied").

Let's fix this by special-casing an empty string as path as referring to
the current directory.

Note: It is unclear to me why the `winsymlinks:nativestrict` code path
even tries to simplify the symbolic link's target path (e.g. turn an
absolute path into a relative one). As long as it refers to a regular
Win32 file or directory, I would think that even something like
`././c` should have only the slashes converted, not the path
simplified (i.e. `.\.\c` instead of `c`). But that's a larger
discussion, and I would like to have the bug worked around swiftly.

Fixes: 827743ab76 (Cygwin: symlink_native: allow linking to `..`, 2025-06-20)
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
(cherry picked from commit 60c67169d69577179bfe7b7f9d8c40fdb0a9b5f7)
---
 winsup/cygwin/path.cc       | 5 ++++-
 winsup/cygwin/release/3.6.5 | 2 ++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/winsup/cygwin/path.cc b/winsup/cygwin/path.cc
index ed08398930..8aff97acbe 100644
--- a/winsup/cygwin/path.cc
+++ b/winsup/cygwin/path.cc
@@ -1895,7 +1895,10 @@ symlink_native (const char *oldpath, path_conv &win32_newpath)
 	    e_old = wcpcpy (e_old, L"..\\"), num--;
 	  if (num > 0)
 	    e_old = wcpcpy (e_old, L"..");
-	  wcpcpy (e_old, c_old);
+	  if (e_old == final_oldpath->Buffer && c_old[0] == L'\0')
+	    wcpcpy (e_old, L".");
+	  else
+	    wcpcpy (e_old, c_old);
 	}
     }
   /* If the symlink target doesn't exist, don't create native symlink.
diff --git a/winsup/cygwin/release/3.6.5 b/winsup/cygwin/release/3.6.5
index d7cf8381f4..8a4eff051a 100644
--- a/winsup/cygwin/release/3.6.5
+++ b/winsup/cygwin/release/3.6.5
@@ -29,3 +29,5 @@ Fixes:
 - Fix multi-thread safety of fork()/exec() by adding the same locking as was
   done for spawn.
   Addresses: https://cygwin.com/pipermail/cygwin/2025-September/258801.html
+
+- Fix native symlink to '.' (a regresison in 3.6.4)

From 39b4a0d5f23f0593b1e4ad951ec22ab23a402e0c Mon Sep 17 00:00:00 2001
From: Kaleb Barrett <dev.ktbarrett@gmail.com>
Date: Sun, 14 Mar 2021 18:58:55 -0500
Subject: [PATCH 21/84] Fix msys library name in import libraries

Cygwin's speclib doesn't handle dashes or dots. However, we are about to
rename the output file name from `cygwin1.dll` to `msys-2.0.dll`.

Let's preemptively fix up all the import libraries that would link
against `msys_2_0.dll` to correctly link against `msys-2.0.dll` instead.
---
 winsup/cygwin/scripts/speclib | 1 +
 1 file changed, 1 insertion(+)

diff --git a/winsup/cygwin/scripts/speclib b/winsup/cygwin/scripts/speclib
index 41a3a8e139..42a02c511b 100755
--- a/winsup/cygwin/scripts/speclib
+++ b/winsup/cygwin/scripts/speclib
@@ -38,6 +38,7 @@ while (<$nm_fd>) {
     study;
     if (/ I _?(.*)_dll_iname/o) {
 	$dllname = $1;
+	$dllname =~ s/_2_0/-2.0/;
     } else {
 	my ($file, $member, $symbol) = m%^([^:]*):([^:]*(?=:))?.* T (.*)%o;
 	next if !defined($symbol) || $symbol =~ $exclude_regex;

From baeb79eaef742dad98293ad6957708fe924e786a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B5=D0=B8=CC=86=20=D0=9F?=
 =?UTF-8?q?=D0=B0=D0=B2=D0=BB=D0=BE=D0=B2?= <alexey.pawlow@gmail.com>
Date: Sun, 14 Apr 2019 21:09:17 +0300
Subject: [PATCH 22/84] Rename dll from cygwin to msys

---
 winsup/cygserver/transport_pipes.h            |  4 +++
 winsup/cygwin/Makefile.am                     | 27 ++++++++++---------
 winsup/cygwin/crt0.c                          |  8 ++++++
 winsup/cygwin/cygwin.din                      |  6 ++---
 winsup/cygwin/cygwin.sc.in                    |  4 +++
 winsup/cygwin/dcrt0.cc                        |  4 +++
 winsup/cygwin/dlfcn.cc                        |  5 ++++
 winsup/cygwin/dll_init.cc                     |  4 +++
 winsup/cygwin/dtable.cc                       |  6 +++++
 winsup/cygwin/exceptions.cc                   |  4 +--
 winsup/cygwin/fhandler/pipe.cc                |  4 +++
 winsup/cygwin/fhandler/pty.cc                 | 26 ++++++++++++++++++
 winsup/cygwin/hookapi.cc                      |  4 +++
 winsup/cygwin/include/cygwin/cygwin_dll.h     | 10 +++----
 winsup/cygwin/include/cygwin/version.h        |  8 ++++++
 winsup/cygwin/lib/_cygwin_crt0_common.cc      |  4 +++
 winsup/cygwin/lib/crt0.h                      |  4 +++
 winsup/cygwin/lib/cygwin_attach_dll.c         |  8 ++++++
 winsup/cygwin/lib/cygwin_crt0.c               |  8 ++++++
 .../cygwin/local_includes/cygserver_setpwd.h  |  4 +++
 winsup/cygwin/scripts/mkvers.sh               |  6 ++---
 winsup/cygwin/sec/auth.cc                     |  8 +++---
 winsup/cygwin/syscalls.cc                     |  4 +--
 winsup/cygwin/syslog.cc                       |  4 +++
 winsup/cygwin/winver.rc                       |  2 +-
 winsup/testsuite/winsup.api/cygload.cc        | 10 +++----
 winsup/testsuite/winsup.api/cygload.h         |  2 +-
 winsup/utils/ldd.cc                           |  2 +-
 winsup/utils/loadlib.h                        |  6 ++---
 winsup/utils/mingw/cygcheck.cc                | 27 +++++++++----------
 winsup/utils/mingw/strace.cc                  |  9 +++----
 winsup/utils/path.cc                          | 12 ++++-----
 winsup/utils/ssp.c                            |  8 +++---
 33 files changed, 180 insertions(+), 72 deletions(-)

diff --git a/winsup/cygserver/transport_pipes.h b/winsup/cygserver/transport_pipes.h
index e101623d24..66272bc86c 100644
--- a/winsup/cygserver/transport_pipes.h
+++ b/winsup/cygserver/transport_pipes.h
@@ -11,7 +11,11 @@ details. */
 #ifndef _TRANSPORT_PIPES_H
 #define _TRANSPORT_PIPES_H
 
+#ifdef __MSYS__
+#define PIPE_NAME_PREFIX	L"\\\\.\\pipe\\msys-"
+#else
 #define PIPE_NAME_PREFIX	L"\\\\.\\pipe\\cygwin-"
+#endif
 #define PIPE_NAME_SUFFIX	L"-lpc"
 
 /* Named pipes based transport, for security on NT */
diff --git a/winsup/cygwin/Makefile.am b/winsup/cygwin/Makefile.am
index 383f4f34a9..981877d733 100644
--- a/winsup/cygwin/Makefile.am
+++ b/winsup/cygwin/Makefile.am
@@ -37,12 +37,12 @@ newlib_build=$(target_builddir)/newlib
 toollibdir=$(tooldir)/lib
 toolincludedir=$(tooldir)/include
 
-# Parameters used in building the cygwin.dll.
+# Parameters used in building the msys-2.0.dll.
 
-DLL_NAME=cygwin1.dll
-NEW_DLL_NAME=new-cygwin1.dll
-DEF_FILE=cygwin.def
-LIB_NAME=libcygwin.a
+DLL_NAME=msys-2.0.dll
+NEW_DLL_NAME=new-msys-2.0.dll
+DEF_FILE=msys.def
+LIB_NAME=libmsys-2.0.a
 
 #
 # sources
@@ -589,16 +589,16 @@ LIBSERVER = $(cygserver_blddir)/libcygserver.a
 $(LIBSERVER):
 	$(MAKE) -C $(cygserver_blddir) libcygserver.a
 
-# We build as new-cygwin1.dll and rename at install time to overcome native
+# We build as new-msys-2.0.dll and rename at install time to overcome native
 # rebuilding issues (we don't want the build tools to see a partially built
-# cygwin1.dll and attempt to use it instead of the old one).
+# msys-2.0.dll and attempt to use it instead of the old one).
 
 # linker script
 LDSCRIPT=cygwin.sc
 $(LDSCRIPT): $(LDSCRIPT).in
 	$(AM_V_GEN)$(CC) -E - -P < $^ -o $@
 
-# cygwin dll
+# msys-2.0 dll
 # Set PE and export table header timestamps to zero for reproducible builds.
 $(NEW_DLL_NAME): $(LDSCRIPT) libdll.a $(VERSION_OFILES) $(LIBSERVER)\
 		  $(newlib_build)/libm.a $(newlib_build)/libc.a
@@ -607,18 +607,18 @@ $(NEW_DLL_NAME): $(LDSCRIPT) libdll.a $(VERSION_OFILES) $(LIBSERVER)\
 	-Wl,--gc-sections -nostdlib -Wl,-T$(LDSCRIPT) \
 	-Wl,--dynamicbase -static \
 	$${SOURCE_DATE_EPOCH:+-Wl,--no-insert-timestamp} \
-	-Wl,--heap=0 -Wl,--out-implib,cygdll.a -shared -o $@ \
+	-Wl,--heap=0 -Wl,--out-implib,msysdll.a -shared -o $@ \
 	-e @DLL_ENTRY@ $(DEF_FILE) \
 	-Wl,-whole-archive libdll.a -Wl,-no-whole-archive \
 	$(VERSION_OFILES) \
 	$(LIBSERVER) \
 	$(newlib_build)/libm.a \
 	$(newlib_build)/libc.a \
-	-lgcc -lkernel32 -lntdll -Wl,-Map,cygwin.map
+	-lgcc -lkernel32 -lntdll -Wl,-Map,msys.map
 	@$(MKDIR_P) ${target_builddir}/winsup/testsuite/testinst/bin/
 	$(AM_V_at)$(INSTALL_PROGRAM) $(NEW_DLL_NAME) ${target_builddir}/winsup/testsuite/testinst/bin/$(DLL_NAME)
 
-# cygwin import library
+# msys-2.0 import library
 toolopts=--cpu=@target_cpu@ --ar=@AR@ --as=@AS@ --nm=@NM@ --objcopy=@OBJCOPY@
 
 $(DEF_FILE): scripts/gendef cygwin.din
@@ -631,13 +631,14 @@ sigfe.s: $(DEF_FILE) tlsoffsets
 
 LIBCOS=$(addsuffix .o,$(basename $(LIB_FILES)))
 $(LIB_NAME): $(DEF_FILE) $(LIBCOS) | $(NEW_DLL_NAME)
-	$(AM_V_GEN)$(srcdir)/scripts/mkimport $(toolopts) $(NEW_FUNCTIONS) $@ cygdll.a $(wordlist 2,99,$^)
+	$(AM_V_GEN)$(srcdir)/scripts/mkimport $(toolopts) $(NEW_FUNCTIONS) $@ msysdll.a $(wordlist 2,99,$^)
 
 # sublibs
 # import libraries for some subset of symbols indicated by given objects
 speclib=\
 	$(srcdir)/scripts/speclib $(toolopts) \
 	--exclude='cygwin' \
+	--exclude='msys' \
 	--exclude='(?i:dll)' \
 	--exclude='reloc' \
 	--exclude='^main$$' \
@@ -687,7 +688,7 @@ all-local: $(LIB_NAME) $(SUBLIBS)
 clean-local:
 	-rm -f $(BUILT_SOURCES)
 	-rm -f $(DEF_FILE) sigfe.s
-	-rm -f cygwin.sc cygdll.a cygwin.map
+	-rm -f cygwin.sc msysdll.a msys.map
 	-rm -f $(NEW_DLL_NAME)
 	-rm -f $(LIB_NAME) $(SUBLIBS)
 	-rm -f version.cc
diff --git a/winsup/cygwin/crt0.c b/winsup/cygwin/crt0.c
index 1096e58970..3160df4491 100644
--- a/winsup/cygwin/crt0.c
+++ b/winsup/cygwin/crt0.c
@@ -9,12 +9,20 @@ details. */
 
 extern int main (int argc, char **argv);
 
+#ifdef __MSYS__
+void msys_crt0 (int (*main) (int, char **));
+#else
 void cygwin_crt0 (int (*main) (int, char **));
+#endif
 
 void
 mainCRTStartup ()
 {
+#ifdef __MSYS__
+  msys_crt0 (main);
+#else
   cygwin_crt0 (main);
+#endif
 
   /* These are never actually called.  They are just here to force the inclusion
      of things like -lbinmode.  */
diff --git a/winsup/cygwin/cygwin.din b/winsup/cygwin/cygwin.din
index deac201c08..073b8d07f4 100644
--- a/winsup/cygwin/cygwin.din
+++ b/winsup/cygwin/cygwin.din
@@ -1,4 +1,4 @@
-LIBRARY "cygwin1.dll" BASE=0x180040000
+LIBRARY "msys-2.0.dll" BASE=0x180040000
 
 EXPORTS
 # Exported variables
@@ -404,8 +404,8 @@ cygwin_attach_handle_to_fd SIGFE
 cygwin_conv_path SIGFE
 cygwin_conv_path_list SIGFE
 cygwin_create_path SIGFE
-cygwin_detach_dll SIGFE_MAYBE
-cygwin_dll_init NOSIGFE
+msys_detach_dll SIGFE_MAYBE
+msys_dll_init NOSIGFE
 cygwin_internal NOSIGFE
 cygwin_logon_user SIGFE
 cygwin_posix_path_list_p NOSIGFE
diff --git a/winsup/cygwin/cygwin.sc.in b/winsup/cygwin/cygwin.sc.in
index 69526f5d8a..4dc5daed8d 100644
--- a/winsup/cygwin/cygwin.sc.in
+++ b/winsup/cygwin/cygwin.sc.in
@@ -1,6 +1,10 @@
 #ifdef __x86_64__
 OUTPUT_FORMAT(pei-x86-64)
+# ifdef __MSYS__
+SEARCH_DIR("/usr/x86_64-pc-msys/lib/w32api"); SEARCH_DIR("=/usr/lib/w32api");
+# else
 SEARCH_DIR("/usr/x86_64-pc-cygwin/lib/w32api"); SEARCH_DIR("=/usr/lib/w32api");
+# endif
 #else
 #error unimplemented for this target
 #endif
diff --git a/winsup/cygwin/dcrt0.cc b/winsup/cygwin/dcrt0.cc
index f4c09befd6..e19b7d3904 100644
--- a/winsup/cygwin/dcrt0.cc
+++ b/winsup/cygwin/dcrt0.cc
@@ -1077,7 +1077,11 @@ dll_crt0 (per_process *uptr)
    See winsup/testsuite/cygload for an example of how to use cygwin1.dll
    from MSVC and non-cygwin MinGW applications.  */
 extern "C" void
+#ifdef __MSYS__
+msys_dll_init ()
+#else
 cygwin_dll_init ()
+#endif
 {
   static int _fmode;
 
diff --git a/winsup/cygwin/dlfcn.cc b/winsup/cygwin/dlfcn.cc
index e06616d7fa..40d99ddeff 100644
--- a/winsup/cygwin/dlfcn.cc
+++ b/winsup/cygwin/dlfcn.cc
@@ -148,8 +148,13 @@ collect_basenames (pathfinder::basenamelist & basenames,
   /* If the basename starts with "lib", ... */
   if (!strncmp (basename, "lib", 3))
     {
+#ifdef __MSYS__
+      /* ... replace "lib" with "msys-", before ... */
+      basenames.appendv ("msys-", 5, basename+3, baselen-3, ext, extlen, NULL);
+#else
       /* ... replace "lib" with "cyg", before ... */
       basenames.appendv ("cyg", 3, basename+3, baselen-3, ext, extlen, NULL);
+#endif
     }
   /* ... using original basename with new suffix. */
   basenames.appendv (basename, baselen, ext, extlen, NULL);
diff --git a/winsup/cygwin/dll_init.cc b/winsup/cygwin/dll_init.cc
index 1369165c9f..5488737c57 100644
--- a/winsup/cygwin/dll_init.cc
+++ b/winsup/cygwin/dll_init.cc
@@ -903,7 +903,11 @@ dll_dllcrt0_1 (VOID *x)
 }
 
 extern "C" void
+#ifdef __MSYS__
+msys_detach_dll (dll *)
+#else
 cygwin_detach_dll (dll *)
+#endif
 {
   HANDLE retaddr;
   if (_my_tls.isinitialized ())
diff --git a/winsup/cygwin/dtable.cc b/winsup/cygwin/dtable.cc
index 7303f7eacc..6ccc19a715 100644
--- a/winsup/cygwin/dtable.cc
+++ b/winsup/cygwin/dtable.cc
@@ -997,9 +997,15 @@ handle_to_fn (HANDLE h, char *posix_fn)
       if (wcsncasecmp (w32, DEV_NAMED_PIPE, DEV_NAMED_PIPE_LEN) == 0)
 	{
 	  w32 += DEV_NAMED_PIPE_LEN;
+#ifdef __MSYS__
+	  if (wcsncmp (w32, L"msys-", WCLEN (L"msys-")) != 0)
+	    return false;
+	  w32 += WCLEN (L"msys-");
+#else
 	  if (wcsncmp (w32, L"cygwin-", WCLEN (L"cygwin-")) != 0)
 	    return false;
 	  w32 += WCLEN (L"cygwin-");
+#endif
 	  /* Check for installation key and trailing dash. */
 	  w32len = cygheap->installation_key.Length / sizeof (WCHAR);
 	  if (w32len
diff --git a/winsup/cygwin/exceptions.cc b/winsup/cygwin/exceptions.cc
index f79978f732..e724e37339 100644
--- a/winsup/cygwin/exceptions.cc
+++ b/winsup/cygwin/exceptions.cc
@@ -528,14 +528,14 @@ int exec_prepared_command (PWCHAR command)
   PWCHAR rawenv = GetEnvironmentStringsW () ;
   for (PWCHAR p = rawenv; *p != L'\0'; p = wcschr (p, L'\0') + 1)
     {
-      if (wcsncmp (p, L"CYGWIN=", wcslen (L"CYGWIN=")) == 0)
+      if (wcsncmp (p, L"MSYS=", wcslen (L"MSYS=")) == 0)
 	{
 	  PWCHAR q = wcsstr (p, L"error_start") ;
 	  /* replace 'error_start=...' with '_rror_start=...' */
 	  if (q)
 	    {
 	      *q = L'_' ;
-	      SetEnvironmentVariableW (L"CYGWIN", p + wcslen (L"CYGWIN=")) ;
+	      SetEnvironmentVariableW (L"MSYS", p + wcslen (L"MSYS=")) ;
 	    }
 	  break;
 	}
diff --git a/winsup/cygwin/fhandler/pipe.cc b/winsup/cygwin/fhandler/pipe.cc
index 2ff5dfa2f7..11ef78c73b 100644
--- a/winsup/cygwin/fhandler/pipe.cc
+++ b/winsup/cygwin/fhandler/pipe.cc
@@ -798,7 +798,11 @@ fhandler_pipe::close (int flag)
   return ret;
 }
 
+#ifdef __MSYS__
+#define PIPE_INTRO "\\\\.\\pipe\\msys-"
+#else
 #define PIPE_INTRO "\\\\.\\pipe\\cygwin-"
+#endif
 
 /* Create a pipe, and return handles to the read and write ends,
    just like CreatePipe, but ensure that the write end permits
diff --git a/winsup/cygwin/fhandler/pty.cc b/winsup/cygwin/fhandler/pty.cc
index 468bc3bc3f..d97e604e90 100644
--- a/winsup/cygwin/fhandler/pty.cc
+++ b/winsup/cygwin/fhandler/pty.cc
@@ -879,7 +879,11 @@ fhandler_pty_slave::open (int flags, mode_t)
       pipe_reply repl;
       DWORD len;
 
+#ifdef __MSYS__
+      __small_sprintf (buf, "\\\\.\\pipe\\msys-%S-pty%d-master-ctl",
+#else
       __small_sprintf (buf, "\\\\.\\pipe\\cygwin-%S-pty%d-master-ctl",
+#endif
 		       &cygheap->installation_key, get_minor ());
       termios_printf ("dup handles via master control pipe %s", buf);
       if (!CallNamedPipe (buf, &req, sizeof req, &repl, sizeof repl,
@@ -1141,7 +1145,11 @@ fhandler_pty_slave::reset_switch_to_nat_pipe (void)
 		    {
 		      char pipe[MAX_PATH];
 		      __small_sprintf (pipe,
+#ifdef __MSYS__
+			       "\\\\.\\pipe\\msys-%S-pty%d-master-ctl",
+#else
 			       "\\\\.\\pipe\\cygwin-%S-pty%d-master-ctl",
+#endif
 			       &cygheap->installation_key, get_minor ());
 		      pipe_request req = { GET_HANDLES, GetCurrentProcessId () };
 		      pipe_reply repl;
@@ -1602,9 +1610,15 @@ fhandler_pty_slave::tcflush (int queue)
   if (queue == TCIFLUSH || queue == TCIOFLUSH)
     {
       char pipe[MAX_PATH];
+#ifdef __MSYS__
+      __small_sprintf (pipe,
+		       "\\\\.\\pipe\\msys-%S-pty%d-master-ctl",
+		       &cygheap->installation_key, get_minor ());
+#else
       __small_sprintf (pipe,
 		       "\\\\.\\pipe\\cygwin-%S-pty%d-master-ctl",
 		       &cygheap->installation_key, get_minor ());
+#endif
       pipe_request req = { FLUSH_INPUT, GetCurrentProcessId () };
       pipe_reply repl;
       DWORD n;
@@ -2036,7 +2050,11 @@ fhandler_pty_master::close (int flag)
 	  pipe_reply repl;
 	  DWORD len;
 
+#ifdef __MSYS__
+	  __small_sprintf (buf, "\\\\.\\pipe\\msys-%S-pty%d-master-ctl",
+#else
 	  __small_sprintf (buf, "\\\\.\\pipe\\cygwin-%S-pty%d-master-ctl",
+#endif
 			   &cygheap->installation_key, get_minor ());
 	  acquire_output_mutex (mutex_timeout);
 	  if (master_ctl)
@@ -2946,7 +2964,11 @@ fhandler_pty_master::setup ()
 
   /* Create master control pipe which allows the master to duplicate
      the pty pipe handles to processes which deserve it. */
+#ifdef __MSYS__
+  __small_sprintf (buf, "\\\\.\\pipe\\msys-%S-pty%d-master-ctl",
+#else
   __small_sprintf (buf, "\\\\.\\pipe\\cygwin-%S-pty%d-master-ctl",
+#endif
 		   &cygheap->installation_key, unit);
   master_ctl = CreateNamedPipe (buf, PIPE_ACCESS_DUPLEX
 				     | FILE_FLAG_FIRST_PIPE_INSTANCE,
@@ -3836,7 +3858,11 @@ fhandler_pty_slave::transfer_input (tty::xfer_dir dir, HANDLE from, tty *ttyp,
     {
       char pipe[MAX_PATH];
       __small_sprintf (pipe,
+#ifdef __MSYS__
+		       "\\\\.\\pipe\\msys-%S-pty%d-master-ctl",
+#else
 		       "\\\\.\\pipe\\cygwin-%S-pty%d-master-ctl",
+#endif
 		       &cygheap->installation_key, ttyp->get_minor ());
       pipe_request req = { GET_HANDLES, GetCurrentProcessId () };
       pipe_reply repl;
diff --git a/winsup/cygwin/hookapi.cc b/winsup/cygwin/hookapi.cc
index ee2edbafee..9f31a716c4 100644
--- a/winsup/cygwin/hookapi.cc
+++ b/winsup/cygwin/hookapi.cc
@@ -379,7 +379,11 @@ hook_or_detect_cygwin (const char *name, const void *fn, WORD& subsys, HANDLE h)
   for (PIMAGE_IMPORT_DESCRIPTOR pd = pdfirst; pd->FirstThunk; pd++)
     {
       if (!ascii_strcasematch (rva (PSTR, map ?: (char *) hm, pd->Name - delta),
+#ifdef __MSYS__
+			       "msys-2.0.dll"))
+#else
 			       "cygwin1.dll"))
+#endif
 	continue;
       if (!fn)
 	{
diff --git a/winsup/cygwin/include/cygwin/cygwin_dll.h b/winsup/cygwin/include/cygwin/cygwin_dll.h
index 1e4cf98ba5..b77598bb63 100644
--- a/winsup/cygwin/include/cygwin/cygwin_dll.h
+++ b/winsup/cygwin/include/cygwin/cygwin_dll.h
@@ -24,8 +24,8 @@ details. */
 CDECL_BEGIN								      \
   int Entry (HINSTANCE h, DWORD reason, void *ptr);	              \
   typedef int (*mainfunc) (int, char **, char **);			      \
-  extern PVOID cygwin_attach_dll (HMODULE, mainfunc);			      \
-  extern void cygwin_detach_dll (PVOID);				      \
+  extern PVOID msys_attach_dll (HMODULE, mainfunc);			      \
+  extern void msys_detach_dll (PVOID);				      \
 CDECL_END								      \
 									      \
 static HINSTANCE storedHandle;						      \
@@ -42,7 +42,7 @@ static int __dllMain (int a __attribute__ ((__unused__)),		      \
 									      \
 static PVOID dll_index;							      \
 									      \
-int _cygwin_dll_entry (HINSTANCE h, DWORD reason, void *ptr)	      \
+int _msys_dll_entry (HINSTANCE h, DWORD reason, void *ptr)	      \
 {									      \
   int ret;								      \
   ret = 1;								      \
@@ -55,7 +55,7 @@ int _cygwin_dll_entry (HINSTANCE h, DWORD reason, void *ptr)	      \
       storedReason = reason;						      \
       storedPtr = ptr;							      \
       __dynamically_loaded = (ptr == NULL);				      \
-      dll_index = cygwin_attach_dll (h, &__dllMain);			      \
+      dll_index = msys_attach_dll (h, &__dllMain);			      \
       if (dll_index == (PVOID) -1)					      \
 	ret = 0;							      \
     }									      \
@@ -66,7 +66,7 @@ int _cygwin_dll_entry (HINSTANCE h, DWORD reason, void *ptr)	      \
       ret = Entry (h, reason, ptr);					      \
       if (ret)								      \
       {									      \
-	cygwin_detach_dll (dll_index);					      \
+	msys_detach_dll (dll_index);					      \
 	dll_index = (PVOID) -1;						      \
       }									      \
     }									      \
diff --git a/winsup/cygwin/include/cygwin/version.h b/winsup/cygwin/include/cygwin/version.h
index 69c19f535b..e0f87a31f6 100644
--- a/winsup/cygwin/include/cygwin/version.h
+++ b/winsup/cygwin/include/cygwin/version.h
@@ -510,7 +510,11 @@ details. */
    names include the CYGWIN_VERSION_SHARED_DATA version as well as this
    identifier. */
 
+#ifdef __MSYS__
+#define CYGWIN_VERSION_DLL_IDENTIFIER	"msys-2.0"
+#else
 #define CYGWIN_VERSION_DLL_IDENTIFIER	"cygwin1"
+#endif
 
 /* The Cygwin mount table interface in the Win32 registry also has a version
    number associated with it in case that is changed in a non-backwards
@@ -526,7 +530,11 @@ details. */
 
 /* Identifiers used in the Win32 registry. */
 
+#ifdef __MSYS__
+#define CYGWIN_INFO_CYGWIN_REGISTRY_NAME "MSYS"
+#else
 #define CYGWIN_INFO_CYGWIN_REGISTRY_NAME "Cygwin"
+#endif
 #define CYGWIN_INFO_INSTALLATIONS_NAME   "Installations"
 
 /* The default cygdrive prefix. */
diff --git a/winsup/cygwin/lib/_cygwin_crt0_common.cc b/winsup/cygwin/lib/_cygwin_crt0_common.cc
index d356a50fba..801b6f91ca 100644
--- a/winsup/cygwin/lib/_cygwin_crt0_common.cc
+++ b/winsup/cygwin/lib/_cygwin_crt0_common.cc
@@ -73,7 +73,11 @@ struct per_process_cxx_malloc __cygwin_cxx_malloc =
    and then jump to the dll.  */
 
 int
+#ifdef __MSYS__
+_msys_crt0_common (MainFunc f, per_process *u)
+#else
 _cygwin_crt0_common (MainFunc f, per_process *u)
+#endif
 {
   per_process *newu = (per_process *) cygwin_internal (CW_USER_DATA);
   bool uwasnull;
diff --git a/winsup/cygwin/lib/crt0.h b/winsup/cygwin/lib/crt0.h
index e599b44934..e81750032b 100644
--- a/winsup/cygwin/lib/crt0.h
+++ b/winsup/cygwin/lib/crt0.h
@@ -13,7 +13,11 @@ extern "C" {
 #include "winlean.h"
 struct per_process;
 typedef int (*MainFunc) (int argc, char *argv[], char **env);
+#ifdef __MSYS__
+int _msys_crt0_common (MainFunc, struct per_process *);
+#else
 int _cygwin_crt0_common (MainFunc, struct per_process *);
+#endif
 PVOID dll_dllcrt0 (HMODULE, struct per_process *);
 
 #ifdef __cplusplus
diff --git a/winsup/cygwin/lib/cygwin_attach_dll.c b/winsup/cygwin/lib/cygwin_attach_dll.c
index 866bfd80fa..82679c4a97 100644
--- a/winsup/cygwin/lib/cygwin_attach_dll.c
+++ b/winsup/cygwin/lib/cygwin_attach_dll.c
@@ -15,10 +15,18 @@ details. */
 
 /* for a loaded dll */
 PVOID
+#ifdef __MSYS__
+msys_attach_dll (HMODULE h, MainFunc f)
+#else
 cygwin_attach_dll (HMODULE h, MainFunc f)
+#endif
 {
   static struct per_process u;
+#ifdef __MSYS__
+  (void) _msys_crt0_common (f, &u);
+#else
   (void) _cygwin_crt0_common (f, &u);
+#endif
 
   /* jump into the dll. */
   return dll_dllcrt0 (h, &u);
diff --git a/winsup/cygwin/lib/cygwin_crt0.c b/winsup/cygwin/lib/cygwin_crt0.c
index 7020a639dd..396447e52e 100644
--- a/winsup/cygwin/lib/cygwin_crt0.c
+++ b/winsup/cygwin/lib/cygwin_crt0.c
@@ -14,8 +14,16 @@ extern void _dll_crt0 ()
 
 /* for main module */
 void
+#ifdef __MSYS__
+msys_crt0 (MainFunc f)
+#else
 cygwin_crt0 (MainFunc f)
+#endif
 {
+#ifdef __MSYS__
+  _msys_crt0_common (f, NULL);
+#else
   _cygwin_crt0_common (f, NULL);
+#endif
   _dll_crt0 ();	/* Jump into the dll, never to return */
 }
diff --git a/winsup/cygwin/local_includes/cygserver_setpwd.h b/winsup/cygwin/local_includes/cygserver_setpwd.h
index fc1576b059..b2975111cf 100644
--- a/winsup/cygwin/local_includes/cygserver_setpwd.h
+++ b/winsup/cygwin/local_includes/cygserver_setpwd.h
@@ -12,7 +12,11 @@ details. */
 #include <sys/types.h>
 #include "cygserver.h"
 
+#ifdef __MSYS__
+#define CYGWIN_LSA_KEY_PREFIX	L"L$MSYS_"
+#else
 #define CYGWIN_LSA_KEY_PREFIX	L"L$CYGWIN_"
+#endif
 
 #ifndef __INSIDE_CYGWIN__
 class transport_layer_base;
diff --git a/winsup/cygwin/scripts/mkvers.sh b/winsup/cygwin/scripts/mkvers.sh
index 38f439cd0d..a3d45c5db0 100755
--- a/winsup/cygwin/scripts/mkvers.sh
+++ b/winsup/cygwin/scripts/mkvers.sh
@@ -123,7 +123,7 @@ dir=$(echo $dir | sed -e 's%/include/cygwin.*$%%' -e 's%include/cygwin.*$%.%')
 ) | while read var; do
     read val
 cat <<EOF
-  "%%% Cygwin $var: $val\n"
+  "%%% MSYS $var: $val\n"
 EOF
 done | tee /tmp/mkvers.$$ 1>&9
 
@@ -135,9 +135,9 @@ trap "rm -f /tmp/mkvers.$$" 0 1 2 15
 #
 cat <<EOF 1>&9
 #ifdef DEBUGGING
-  "%%% Cygwin shared id: " CYGWIN_VERSION_DLL_IDENTIFIER "S" shared_data_version "-$builddate\n"
+  "%%% MSYS shared id: " CYGWIN_VERSION_DLL_IDENTIFIER "S" shared_data_version "-$builddate\n"
 #else
-  "%%% Cygwin shared id: " CYGWIN_VERSION_DLL_IDENTIFIER "S" shared_data_version "\n"
+  "%%% MSYS shared id: " CYGWIN_VERSION_DLL_IDENTIFIER "S" shared_data_version "\n"
 #endif
   "END_CYGWIN_VERSION_INFO\n\0";
 cygwin_version_info cygwin_version =
diff --git a/winsup/cygwin/sec/auth.cc b/winsup/cygwin/sec/auth.cc
index f9906a55c6..2361ae5ff9 100644
--- a/winsup/cygwin/sec/auth.cc
+++ b/winsup/cygwin/sec/auth.cc
@@ -462,7 +462,7 @@ verify_token (HANDLE token, cygsid &usersid, user_groups &groups, bool *pintern)
       if (!NT_SUCCESS (status))
 	debug_printf ("NtQueryInformationToken(), %y", status);
       else
-	*pintern = intern = !memcmp (ts.SourceName, "Cygwin.1", 8);
+	*pintern = intern = !memcmp (ts.SourceName, "MSYS.2", 6);
     }
   /* Verify usersid */
   cygsid tok_usersid (NO_SID);
@@ -747,7 +747,7 @@ s4uauth (bool logon, PCWSTR domain, PCWSTR user, NTSTATUS &ret_status)
     {
       /* Register as logon process. */
       debug_printf ("Impersonation requested");
-      RtlInitAnsiString (&name, "Cygwin");
+      RtlInitAnsiString (&name, "MSYS");
       status = LsaRegisterLogonProcess (&name, &lsa_hdl, &sec_mode);
     }
   else
@@ -786,11 +786,11 @@ s4uauth (bool logon, PCWSTR domain, PCWSTR user, NTSTATUS &ret_status)
     }
 
   /* Create origin. */
-  stpcpy (origin.buf, "Cygwin");
+  stpcpy (origin.buf, "MSYS");
   RtlInitAnsiString (&origin.str, origin.buf);
 
   /* Create token source. */
-  memcpy (ts.SourceName, "Cygwin.1", 8);
+  memcpy (ts.SourceName, "MSYS.2", 6);
   ts.SourceIdentifier.HighPart = 0;
   ts.SourceIdentifier.LowPart = kerberos_auth ? 0x0105 : 0x0106;
 
diff --git a/winsup/cygwin/syscalls.cc b/winsup/cygwin/syscalls.cc
index 1b1ff17b0a..eddc0f62fe 100644
--- a/winsup/cygwin/syscalls.cc
+++ b/winsup/cygwin/syscalls.cc
@@ -339,7 +339,7 @@ try_to_bin (path_conv &pc, HANDLE &fh, ACCESS_MASK access, ULONG flags)
     }
   else
     {
-      /* Create unique filename.  Start with a dot, followed by "cyg"
+      /* Create unique filename.  Start with a dot, followed by "msys"
 	 transposed to the Unicode private use area in the U+f700 area
 	 on file systems supporting Unicode (except Samba), followed by
 	 the inode number in hex, followed by a path hash in hex.  The
@@ -347,7 +347,7 @@ try_to_bin (path_conv &pc, HANDLE &fh, ACCESS_MASK access, ULONG flags)
       RtlAppendUnicodeToString (&recycler,
 				(pc.fs_flags () & FILE_UNICODE_ON_DISK
 				 && !pc.fs_is_samba ())
-				? L".\xf763\xf779\xf767" : L".cyg");
+				? L".\xf76d\xf773\xf779\xf773" : L".msys");
       pfii = (PFILE_INTERNAL_INFORMATION) infobuf;
       status = NtQueryInformationFile (fh, &io, pfii, sizeof *pfii,
 				       FileInternalInformation);
diff --git a/winsup/cygwin/syslog.cc b/winsup/cygwin/syslog.cc
index 6a295501f1..431f9d2396 100644
--- a/winsup/cygwin/syslog.cc
+++ b/winsup/cygwin/syslog.cc
@@ -26,7 +26,11 @@ details. */
 #include "cygtls.h"
 #include "tls_pbuf.h"
 
+#ifdef __MSYS__
+#define CYGWIN_LOG_NAME L"MSYS"
+#else
 #define CYGWIN_LOG_NAME L"Cygwin"
+#endif
 
 static struct
 {
diff --git a/winsup/cygwin/winver.rc b/winsup/cygwin/winver.rc
index 980d51204c..58878d41bd 100644
--- a/winsup/cygwin/winver.rc
+++ b/winsup/cygwin/winver.rc
@@ -35,7 +35,7 @@ BEGIN
       VALUE "InternalName", CYGWIN_DLL_NAME
       VALUE "LegalCopyright", "Copyright \251 Cygwin Authors 1996-" STRINGIFY(CYGWIN_BUILD_YEAR)
       VALUE "OriginalFilename", CYGWIN_DLL_NAME
-      VALUE "ProductName", "Cygwin"
+      VALUE "ProductName", "MSYS2"
       VALUE "ProductVersion", STRINGIFY(CYGWIN_VERSION)
       VALUE "APIVersion", CYGWIN_API_VERSION
       VALUE "SharedMemoryVersion", STRINGIFY(CYGWIN_VERSION_SHARED_DATA)
diff --git a/winsup/testsuite/winsup.api/cygload.cc b/winsup/testsuite/winsup.api/cygload.cc
index afd3ee90fc..1b2f79dc05 100644
--- a/winsup/testsuite/winsup.api/cygload.cc
+++ b/winsup/testsuite/winsup.api/cygload.cc
@@ -25,7 +25,7 @@
 		     save for errors.
      -testinterrupts Pauses the program for 30 seconds so you can demonstrate
 		     that it handles ^C properly.
-     -cygwin         Name of DLL to load.  Defaults to "cygwin1.dll". */
+     -cygwin         Name of DLL to load.  Defaults to "msys-2.0.dll". */
 
 #include "cygload.h"
 #include <iostream>
@@ -154,13 +154,13 @@ cygwin::connector::connector (const char *dll)
 
   *out << "Initializing cygwin..." << endl;
 
-  // This calls dcrt0.cc:cygwin_dll_init(), which calls dll_crt0_1(),
+  // This calls dcrt0.cc:msys_dll_init(), which calls dll_crt0_1(),
   // which will, among other things:
   // * spawn the cygwin signal handling thread from sigproc_init()
   // * initialize the thread-local storage for this thread and overwrite
   //   the first 4K of the stack
   void (*cyginit) ();
-  get_symbol ("cygwin_dll_init", cyginit);
+  get_symbol ("msys_dll_init", cyginit);
   (*cyginit) ();
 
   *out << "Loading symbols..." << endl;
@@ -224,7 +224,7 @@ cygwin::connector::~connector ()
 
     // This should call init.cc:dll_entry() with DLL_PROCESS_DETACH.
     if (!FreeLibrary (_library))
-      throw windows_error ("FreeLibrary", "cygwin1.dll");
+      throw windows_error ("FreeLibrary", "msys-2.0.dll");
   }
   catch (std::exception &x)
   {
@@ -490,7 +490,7 @@ main (int argc, char *argv[])
 
   std::ostringstream output;
   bool verbose = false, testinterrupts = false;
-  const char *dll = "cygwin1.dll";
+  const char *dll = "msys-2.0.dll";
 
   out = &output;
 
diff --git a/winsup/testsuite/winsup.api/cygload.h b/winsup/testsuite/winsup.api/cygload.h
index 30154048b0..0f2aacda9a 100644
--- a/winsup/testsuite/winsup.api/cygload.h
+++ b/winsup/testsuite/winsup.api/cygload.h
@@ -76,7 +76,7 @@ namespace cygwin
   // spawns a thread to let you receive signals from cygwin.
   class connector {
   public:
-    connector (const char *dll = "cygwin1.dll");
+    connector (const char *dll = "msys-2.0.dll");
     ~connector ();
 
     // A wrapper around GetProcAddress() for fetching symbols from the
diff --git a/winsup/utils/ldd.cc b/winsup/utils/ldd.cc
index 0d073c2989..a31c4c6e44 100644
--- a/winsup/utils/ldd.cc
+++ b/winsup/utils/ldd.cc
@@ -249,7 +249,7 @@ tocyg (wchar_t *win_fn)
   return fn;
 }
 
-#define CYGWIN_DLL_LEN (wcslen (L"\\cygwin1.dll"))
+#define CYGWIN_DLL_LEN (wcslen (L"\\msys-2.0.dll"))
 static int
 print_dlls (dlls *dll, const wchar_t *dllfn, const wchar_t *process_fn)
 {
diff --git a/winsup/utils/loadlib.h b/winsup/utils/loadlib.h
index c83b76478f..42ffbfdc03 100644
--- a/winsup/utils/loadlib.h
+++ b/winsup/utils/loadlib.h
@@ -13,7 +13,7 @@
 #include <wchar.h>
 
 /* Load all system libs from the windows system directory by prepending the
-   full path.  This doesn't work for loadling cygwin1.dll.  For this case,
+   full path.  This doesn't work for loadling msys-2.0.dll.  For this case,
    instead of prepending the path, make sure that the CWD is removed from
    the DLL search path, if possible (XP SP1++, Vista++). */
 static HMODULE _load_sys_library (const wchar_t *dll) __attribute__ ((used));
@@ -45,8 +45,8 @@ _load_sys_library (const wchar_t *dll)
       	set_dll_directory (L"");
     }
 
-  if (wcscmp (dll, L"cygwin1.dll") == 0)
-    return LoadLibraryExW (L"cygwin1.dll", NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+  if (wcscmp (dll, L"msys-2.0.dll") == 0)
+    return LoadLibraryExW (L"msys-2.0.dll", NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
 
   wcscpy (dllpath, sysdir);
   wcscpy (dllpath + sysdir_len, dll);
diff --git a/winsup/utils/mingw/cygcheck.cc b/winsup/utils/mingw/cygcheck.cc
index 89a08e560f..1637683c26 100644
--- a/winsup/utils/mingw/cygcheck.cc
+++ b/winsup/utils/mingw/cygcheck.cc
@@ -95,8 +95,7 @@ static const char *known_env_vars[] = {
   "c_include_path",
   "compiler_path",
   "cxx_include_path",
-  "cygwin",
-  "cygwin32",
+  "msys",
   "dejagnu",
   "expect",
   "gcc_default_options",
@@ -554,7 +553,7 @@ struct ImpDirectory
 
 static bool track_down (const char *file, const char *suffix, int lvl);
 
-#define CYGPREFIX (sizeof ("%%% Cygwin ") - 1)
+#define CYGPREFIX (sizeof ("%%% Msys ") - 1)
 static void
 cygwin_info (HANDLE h)
 {
@@ -586,7 +585,7 @@ cygwin_info (HANDLE h)
   while (buf < bufend)
     if ((buf = (char *) memchr (buf, '%', bufend - buf)) == NULL)
       break;
-    else if (strncmp ("%%% Cygwin ", buf, CYGPREFIX) != 0)
+    else if (strncmp ("%%% Msys ", buf, CYGPREFIX) != 0)
       buf++;
     else
       {
@@ -780,7 +779,7 @@ dll_info (const char *path, HANDLE fh, int lvl, int recurse)
 	    }
 	}
     }
-  if (strstr (path, "\\cygwin1.dll"))
+  if (strstr (path, "\\msys-2.0.dll"))
     cygwin_info (fh);
 }
 
@@ -1027,7 +1026,7 @@ scan_registry (RegInfo * prev, HKEY hKey, char *name, int cygwin, bool wow64)
 
   char *cp;
   for (cp = name; *cp; cp++)
-    if (strncasecmp (cp, "Cygwin", 6) == 0)
+    if (strncasecmp (cp, "Msys", 4) == 0)
       cygwin = 1;
 
   DWORD num_subkeys, max_subkey_len, num_values;
@@ -1309,7 +1308,7 @@ handle_reg_installation (handle_reg_t what)
     printf ("Cygwin installations found in the registry:\n");
   for (int i = 0; i < 2; ++i)
     if (RegOpenKeyEx (i ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE,
-		      "SOFTWARE\\Cygwin\\Installations", 0,
+		      "SOFTWARE\\Msys\\Installations", 0,
 		      what == DELETE_KEY ? KEY_READ | KEY_WRITE : KEY_READ,
 		      &key)
 	== ERROR_SUCCESS)
@@ -1331,7 +1330,7 @@ handle_reg_installation (handle_reg_t what)
 	      if (what == PRINT_KEY)
 		printf ("  %s Key: %s Path: %s", i ? "User:  " : "System:",
 			name, path);
-	      strcat (path, "\\bin\\cygwin1.dll");
+	      strcat (path, "\\bin\\msys-2.0.dll");
 	      if (what == PRINT_KEY)
 		printf ("%s\n", access (path, F_OK) ? " (ORPHANED)" : "");
 	      else if (access (path, F_OK))
@@ -1785,7 +1784,7 @@ dump_sysinfo ()
   if (registry)
     {
       if (givehelp)
-	printf ("Scanning registry for keys with 'Cygwin' in them...\n");
+	printf ("Scanning registry for keys with 'Msys' in them...\n");
       scan_registry (0, HKEY_CURRENT_USER,
 		     (char *) "HKEY_CURRENT_USER", 0, false);
       scan_registry (0, HKEY_LOCAL_MACHINE,
@@ -1980,10 +1979,10 @@ dump_sysinfo ()
 	  wcstombs (f, ffinfo.cFileName, sizeof f);
 	  if (strcasecmp (f + strlen (f) - 4, ".dll") == 0)
 	    {
-	      if (strncasecmp (f, "cyg", 3) == 0)
+	      if (strncasecmp (f, "msys-", 5) == 0)
 		{
 		  sprintf (tmp, "%s%s", pth->dir, f);
-		  if (strcasecmp (f, "cygwin1.dll") == 0)
+		  if (strcasecmp (f, "msys-2.0.dll") == 0)
 		    {
 		      if (!cygwin_dll_count)
 			strcpy (cygdll_path, pth->dir);
@@ -2007,9 +2006,9 @@ dump_sysinfo ()
       FindClose (ff);
     }
   if (cygwin_dll_count > 1)
-    puts ("Warning: There are multiple cygwin1.dlls on your path");
+    puts ("Warning: There are multiple msys-2.0.dlls on your path");
   if (!cygwin_dll_count)
-    puts ("Warning: cygwin1.dll not found on your path");
+    puts ("Warning: msys-2.0.dll not found on your path");
 
   dump_dodgy_apps (verbose);
 
@@ -3023,7 +3022,7 @@ load_cygwin (int& argc, char **&argv)
 {
   HMODULE h;
 
-  if (!(h = LoadLibrary ("cygwin1.dll")))
+  if (!(h = LoadLibrary ("msys-2.0.dll")))
     return;
   GetModuleFileNameW (h, cygwin_dll_path, 32768);
   if ((cygwin_internal = (uintptr_t (*) (cygwin_getinfo_types, ...))
diff --git a/winsup/utils/mingw/strace.cc b/winsup/utils/mingw/strace.cc
index c220643b33..29db640239 100644
--- a/winsup/utils/mingw/strace.cc
+++ b/winsup/utils/mingw/strace.cc
@@ -284,7 +284,7 @@ load_cygwin ()
   if (h)
     return 0;
 
-  if (!(h = LoadLibrary ("cygwin1.dll")))
+  if (!(h = LoadLibrary ("msys-2.0.dll")))
     {
       errno = ENOENT;
       return 0;
@@ -354,17 +354,16 @@ create_child (char **argv)
   make_command_line (one_line, argv);
 
   SetConsoleCtrlHandler (NULL, 0);
-
-  const char *cygwin_env = getenv ("CYGWIN");
+  const char *cygwin_env = getenv ("MSYS");
   const char *space;
 
   if (cygwin_env && strlen (cygwin_env) <= 256) /* sanity check */
     space = " ";
   else
     space = cygwin_env = "";
-  char *newenv = (char *) malloc (sizeof ("CYGWIN=noglob")
+  char *newenv = (char *) malloc (sizeof ("MSYS=noglob")
 				  + strlen (space) + strlen (cygwin_env));
-  sprintf (newenv, "CYGWIN=noglob%s%s", space, cygwin_env);
+  sprintf (newenv, "MSYS=noglob%s%s", space, cygwin_env);
   _putenv (newenv);
   ret = CreateProcess (0, one_line.buf,	/* command line */
 		       NULL,	/* Security */
diff --git a/winsup/utils/path.cc b/winsup/utils/path.cc
index fe55a646d9..323e4c784b 100644
--- a/winsup/utils/path.cc
+++ b/winsup/utils/path.cc
@@ -585,14 +585,14 @@ read_mounts ()
     }
   max_mount_entry = 0;
 
-  /* First fetch the cygwin1.dll path from the LoadLibrary call in load_cygwin.
-     This utilizes the DLL search order to find a matching cygwin1.dll and to
+  /* First fetch the msys-2.0.dll path from the LoadLibrary call in load_cygwin.
+     This utilizes the DLL search order to find a matching msys-2.0.dll and to
      compute the installation path from that DLL's path. */
   if (cygwin_dll_path[0])
     wcscpy (path, cygwin_dll_path);
-  /* If we can't load cygwin1.dll, check where cygcheck is living itself and
-     try to fetch installation path from here.  Does cygwin1.dll exist in the
-     same path?  This should only kick in if the cygwin1.dll in the same path
+  /* If we can't load msys-2.0.dll, check where cygcheck is living itself and
+     try to fetch installation path from here.  Does msys-2.0.dll exist in the
+     same path?  This should only kick in if the msys-2.0.dll in the same path
      has been made non-executable for the current user accidentally. */
   else if (!GetModuleFileNameW (NULL, path, 32768))
     return;
@@ -601,7 +601,7 @@ read_mounts ()
     {
       if (!cygwin_dll_path[0])
 	{
-	  wcscpy (path_end, L"\\cygwin1.dll");
+	  wcscpy (path_end, L"\\msys-2.0.dll");
 	  DWORD attr = GetFileAttributesW (path);
 	  if (attr == (DWORD) -1
 	      || (attr & (FILE_ATTRIBUTE_DIRECTORY
diff --git a/winsup/utils/ssp.c b/winsup/utils/ssp.c
index 96a90a1d98..95045e1e8b 100644
--- a/winsup/utils/ssp.c
+++ b/winsup/utils/ssp.c
@@ -710,15 +710,15 @@ usage (FILE * stream)
     "You must specify the range of memory addresses to keep track of\n"
     "manually, but it's not hard to figure out what to specify.  Use the\n"
     "\"objdump\" program to determine the bounds of the target's \".text\"\n"
-    "section.  Let's say we're profiling cygwin1.dll.  Make sure you've\n"
+    "section.  Let's say we're profiling msys-2.0.dll.  Make sure you've\n"
     "built it with debug symbols (else gprof won't run) and run objdump\n"
     "like this:\n"
     "\n"
-    "	objdump -h cygwin1.dll\n"
+    "	objdump -h msys-2.0.dll\n"
     "\n"
     "It will print a report like this:\n"
     "\n"
-    "cygwin1.dll:     file format pei-i386\n"
+    "msys-2.0.dll:     file format pei-i386\n"
     "\n"
     "Sections:\n"
     "Idx Name          Size      VMA       LMA       File off  Algn\n"
@@ -749,7 +749,7 @@ usage (FILE * stream)
     "\"gmon.out\".  You can turn this data file into a readable report with\n"
     "gprof:\n"
     "\n"
-    "	gprof -b cygwin1.dll\n"
+    "	gprof -b msys-2.0.dll\n"
     "\n"
     "The \"-b\" means 'skip the help pages'.  You can omit this until you're\n"
     "familiar with the report layout.  The gprof documentation explains\n"

From 5031617a9a1d4ec25a4c47a85adcf9e8fbf8b1ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B5=D0=B8=CC=86=20=D0=9F?=
 =?UTF-8?q?=D0=B0=D0=B2=D0=BB=D0=BE=D0=B2?= <alexey.pawlow@gmail.com>
Date: Sun, 14 Apr 2019 21:17:46 +0300
Subject: [PATCH 23/84] Add functionality for converting UNIX paths in
 arguments and environment variables to Windows form for native Win32
 applications.

---
 winsup/cygwin/Makefile.am              |   1 +
 winsup/cygwin/environ.cc               |  24 +-
 winsup/cygwin/external.cc              |   2 +-
 winsup/cygwin/include/sys/cygwin.h     |   6 +
 winsup/cygwin/local_includes/environ.h |   2 +-
 winsup/cygwin/local_includes/winf.h    |   4 +
 winsup/cygwin/msys2_path_conv.cc       | 699 +++++++++++++++++++++++++
 winsup/cygwin/msys2_path_conv.h        | 147 ++++++
 winsup/cygwin/path.cc                  |  69 +++
 winsup/cygwin/spawn.cc                 |  38 +-
 10 files changed, 988 insertions(+), 4 deletions(-)
 create mode 100644 winsup/cygwin/msys2_path_conv.cc
 create mode 100644 winsup/cygwin/msys2_path_conv.h

diff --git a/winsup/cygwin/Makefile.am b/winsup/cygwin/Makefile.am
index 981877d733..54ae637450 100644
--- a/winsup/cygwin/Makefile.am
+++ b/winsup/cygwin/Makefile.am
@@ -314,6 +314,7 @@ DLL_FILES= \
 	miscfuncs.cc \
 	mktemp.cc \
 	msg.cc \
+	msys2_path_conv.cc \
 	mount.cc \
 	net.cc \
 	netdb.cc \
diff --git a/winsup/cygwin/environ.cc b/winsup/cygwin/environ.cc
index d4cedcbdfe..639e69393b 100644
--- a/winsup/cygwin/environ.cc
+++ b/winsup/cygwin/environ.cc
@@ -1046,7 +1046,7 @@ env_compare (const void *key, const void *memb)
    to the child. */
 char **
 build_env (const char * const *envp, PWCHAR &envblock, int &envc,
-	   bool no_envblock, HANDLE new_token)
+	   bool no_envblock, HANDLE new_token, bool keep_posix)
 {
   PWCHAR cwinenv = NULL;
   size_t winnum = 0;
@@ -1139,6 +1139,19 @@ build_env (const char * const *envp, PWCHAR &envblock, int &envc,
   for (srcp = envp, dstp = newenv, pass_dstp = pass_env; *srcp; srcp++)
     {
       bool calc_tl = !no_envblock;
+#ifdef __MSYS__
+      /* Don't pass timezone environment to non-msys applications */
+      if (!keep_posix && ascii_strncasematch(*srcp, "TZ=", 3))
+        {
+          const char *v = *srcp + 3;
+          if (*v == ':')
+            goto next1;
+          for (; *v; v++)
+            if (!isalpha(*v) && !isdigit(*v) &&
+                *v != '-' && *v != '+' && *v != ':')
+              goto next1;
+        }
+#endif
       /* Look for entries that require special attention */
       for (unsigned i = 0; i < SPENVS_SIZE; i++)
 	if (!saw_spenv[i] && (*dstp = spenvs[i].retrieve (no_envblock, *srcp)))
@@ -1259,6 +1272,15 @@ build_env (const char * const *envp, PWCHAR &envblock, int &envc,
 		  saw_PATH = true;
 		}
 	    }
+#ifdef __MSYS__
+	  else if (!keep_posix) {
+	    char *win_arg = arg_heuristic(*srcp);
+	    debug_printf("WIN32_PATH is %s", win_arg);
+	    p = cstrdup1(win_arg);
+	    if (win_arg != *srcp)
+	      free (win_arg);
+	  }
+#endif
 	  else
 	    p = *srcp;		/* Don't worry about it */
 
diff --git a/winsup/cygwin/external.cc b/winsup/cygwin/external.cc
index 50a5af24f9..a20ea078e3 100644
--- a/winsup/cygwin/external.cc
+++ b/winsup/cygwin/external.cc
@@ -141,7 +141,7 @@ create_winenv (const char * const *env)
   int unused_envc;
   PWCHAR envblock = NULL;
   char **envp = build_env (env ?: environ, envblock, unused_envc, false,
-			   NULL);
+			   NULL, true);
   PWCHAR p = envblock;
 
   if (envp)
diff --git a/winsup/cygwin/include/sys/cygwin.h b/winsup/cygwin/include/sys/cygwin.h
index f5c90fe96b..0e11a9b81a 100644
--- a/winsup/cygwin/include/sys/cygwin.h
+++ b/winsup/cygwin/include/sys/cygwin.h
@@ -60,6 +60,12 @@ extern ssize_t cygwin_conv_path_list (cygwin_conv_path_t what, const void *from,
    to one of the above values, or to ENOMEM if malloc fails. */
 extern void *cygwin_create_path (cygwin_conv_path_t what, const void *from);
 
+extern char * arg_heuristic_with_exclusions (char const * const arg,
+					     char const * exclusions,
+					     size_t exclusions_count);
+
+extern char * arg_heuristic (char const * const);
+
 extern pid_t cygwin_winpid_to_pid (int);
 extern int cygwin_posix_path_list_p (const char *);
 extern void cygwin_split_path (const char *, char *, char *);
diff --git a/winsup/cygwin/local_includes/environ.h b/winsup/cygwin/local_includes/environ.h
index 86e64a72f9..0dd45359cc 100644
--- a/winsup/cygwin/local_includes/environ.h
+++ b/winsup/cygwin/local_includes/environ.h
@@ -34,7 +34,7 @@ win_env *getwinenv (const char *name, const char *posix = NULL, win_env * = NULL
 char *getwinenveq (const char *name, size_t len, int);
 
 char **build_env (const char * const *envp, PWCHAR &envblock,
-			  int &envc, bool need_envblock, HANDLE new_token);
+			  int &envc, bool need_envblock, HANDLE new_token, bool keep_posix);
 
 char **win32env_to_cygenv (PWCHAR rawenv, bool posify);
 
diff --git a/winsup/cygwin/local_includes/winf.h b/winsup/cygwin/local_includes/winf.h
index b586934410..bc53cd1aa3 100644
--- a/winsup/cygwin/local_includes/winf.h
+++ b/winsup/cygwin/local_includes/winf.h
@@ -56,6 +56,10 @@ class av
 	calloced = 1;
       }
   }
+  void replace (int i, const char *arg)
+  {
+    argv[i] = cstrdup1 (arg);
+  }
   void dup_all ()
   {
     for (int i = calloced; i < argc; i++)
diff --git a/winsup/cygwin/msys2_path_conv.cc b/winsup/cygwin/msys2_path_conv.cc
new file mode 100644
index 0000000000..c52728759e
--- /dev/null
+++ b/winsup/cygwin/msys2_path_conv.cc
@@ -0,0 +1,699 @@
+/*
+  The MSYS2 Path conversion source code is licensed under:
+  
+  CC0 1.0 Universal
+  
+  Official translations of this legal tool are available
+  
+  CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+  LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+  ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+  INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+  REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+  PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+  THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+  HEREUNDER.
+  
+  Statement of Purpose
+  
+  The laws of most jurisdictions throughout the world automatically
+  confer exclusive Copyright and Related Rights (defined below) upon the
+  creator and subsequent owner(s) (each and all, an "owner") of an
+  original work of authorship and/or a database (each, a "Work").
+  
+  Certain owners wish to permanently relinquish those rights to a Work
+  for the purpose of contributing to a commons of creative, cultural and
+  scientific works ("Commons") that the public can reliably and without
+  fear of later claims of infringement build upon, modify, incorporate
+  in other works, reuse and redistribute as freely as possible in any
+  form whatsoever and for any purposes, including without limitation
+  commercial purposes. These owners may contribute to the Commons to
+  promote the ideal of a free culture and the further production of
+  creative, cultural and scientific works, or to gain reputation or
+  greater distribution for their Work in part through the use and
+  efforts of others.
+  
+  For these and/or other purposes and motivations, and without any
+  expectation of additional consideration or compensation, the person
+  associating CC0 with a Work (the "Affirmer"), to the extent that he or
+  she is an owner of Copyright and Related Rights in the Work,
+  voluntarily elects to apply CC0 to the Work and publicly distribute
+  the Work under its terms, with knowledge of his or her Copyright and
+  Related Rights in the Work and the meaning and intended legal effect
+  of CC0 on those rights.
+  
+  1. Copyright and Related Rights. A Work made available under CC0 may
+  be protected by copyright and related or neighboring rights
+  ("Copyright and Related Rights"). Copyright and Related Rights
+  include, but are not limited to, the following:
+  
+  the right to reproduce, adapt, distribute, perform, display,
+  communicate, and translate a Work;
+  moral rights retained by the original author(s) and/or performer(s);
+  publicity and privacy rights pertaining to a person's image or
+  likeness depicted in a Work;
+  rights protecting against unfair competition in regards to a Work,
+  subject to the limitations in paragraph 4(a), below;
+  rights protecting the extraction, dissemination, use and reuse of data
+  in a Work;
+  database rights (such as those arising under Directive 96/9/EC of the
+  European Parliament and of the Council of 11 March 1996 on the legal
+  protection of databases, and under any national implementation
+  thereof, including any amended or successor version of such
+  directive); and
+  other similar, equivalent or corresponding rights throughout the world
+  based on applicable law or treaty, and any national implementations
+  thereof.
+  
+  2. Waiver. To the greatest extent permitted by, but not in
+  contravention of, applicable law, Affirmer hereby overtly, fully,
+  permanently, irrevocably and unconditionally waives, abandons, and
+  surrenders all of Affirmer's Copyright and Related Rights and
+  associated claims and causes of action, whether now known or unknown
+  (including existing as well as future claims and causes of action), in
+  the Work (i) in all territories worldwide, (ii) for the maximum
+  duration provided by applicable law or treaty (including future time
+  extensions), (iii) in any current or future medium and for any number
+  of copies, and (iv) for any purpose whatsoever, including without
+  limitation commercial, advertising or promotional purposes (the
+  "Waiver"). Affirmer makes the Waiver for the benefit of each member of
+  the public at large and to the detriment of Affirmer's heirs and
+  successors, fully intending that such Waiver shall not be subject to
+  revocation, rescission, cancellation, termination, or any other legal
+  or equitable action to disrupt the quiet enjoyment of the Work by the
+  public as contemplated by Affirmer's express Statement of Purpose.
+  
+  3. Public License Fallback. Should any part of the Waiver for any
+  reason be judged legally invalid or ineffective under applicable law,
+  then the Waiver shall be preserved to the maximum extent permitted
+  taking into account Affirmer's express Statement of Purpose. In
+  addition, to the extent the Waiver is so judged Affirmer hereby grants
+  to each affected person a royalty-free, non transferable, non
+  sublicensable, non exclusive, irrevocable and unconditional license to
+  exercise Affirmer's Copyright and Related Rights in the Work (i) in
+  all territories worldwide, (ii) for the maximum duration provided by
+  applicable law or treaty (including future time extensions), (iii) in
+  any current or future medium and for any number of copies, and (iv)
+  for any purpose whatsoever, including without limitation commercial,
+  advertising or promotional purposes (the "License"). The License shall
+  be deemed effective as of the date CC0 was applied by Affirmer to the
+  Work. Should any part of the License for any reason be judged legally
+  invalid or ineffective under applicable law, such partial invalidity
+  or ineffectiveness shall not invalidate the remainder of the License,
+  and in such case Affirmer hereby affirms that he or she will not (i)
+  exercise any of his or her remaining Copyright and Related Rights in
+  the Work or (ii) assert any associated claims and causes of action
+  with respect to the Work, in either case contrary to Affirmer's
+  express Statement of Purpose.
+  
+  4. Limitations and Disclaimers.
+  
+  No trademark or patent rights held by Affirmer are waived, abandoned,
+  surrendered, licensed or otherwise affected by this document.
+  Affirmer offers the Work as-is and makes no representations or
+  warranties of any kind concerning the Work, express, implied,
+  statutory or otherwise, including without limitation warranties of
+  title, merchantability, fitness for a particular purpose, non
+  infringement, or the absence of latent or other defects, accuracy, or
+  the present or absence of errors, whether or not discoverable, all to
+  the greatest extent permissible under applicable law.
+  Affirmer disclaims responsibility for clearing rights of other persons
+  that may apply to the Work or any use thereof, including without
+  limitation any person's Copyright and Related Rights in the Work.
+  Further, Affirmer disclaims responsibility for obtaining any necessary
+  consents, permissions or other rights required for any use of the
+  Work.
+  Affirmer understands and acknowledges that Creative Commons is not a
+  party to this document and has no duty or obligation with respect to
+  this CC0 or use of the Work.
+
+  Contributions thanks to:
+    niXman <i.nixman@autistici.org>
+    Ely Arzhannikov <iarzhannikov@gmail.com>
+    Alexey Pavlov <alexpux@gmail.com>
+    Ray Donnelly <mingw.android@gmail.com>
+    Johannes Schindelin <johannes.schindelin@gmx.de>
+  
+*/
+
+#include "winsup.h"
+#include "miscfuncs.h"
+#include <ctype.h>
+#include <winioctl.h>
+#include <shlobj.h>
+#include <sys/param.h>
+#include <sys/cygwin.h>
+#include "cygerrno.h"
+#include "security.h"
+#include "path.h"
+#include "fhandler.h"
+#include "dtable.h"
+#include "cygheap.h"
+#include "shared_info.h"
+#include "cygtls.h"
+#include "tls_pbuf.h"
+#include "environ.h"
+#include <assert.h>
+#include <ntdll.h>
+#include <wchar.h>
+#include <wctype.h>
+
+#include "msys2_path_conv.h"
+
+typedef enum PATH_TYPE_E {
+    NONE = 0,
+    SIMPLE_WINDOWS_PATH,
+    ESCAPE_WINDOWS_PATH,
+    WINDOWS_PATH_LIST,
+    UNC,
+    ESCAPED_PATH,
+    ROOTED_PATH,
+    POSIX_PATH_LIST,
+    RELATIVE_PATH,
+    URL
+} path_type;
+
+int is_special_posix_path(const char* from, const char* to, char** dst, const char* dstend);
+void posix_to_win32_path(const char* from, const char* to, char** dst, const char* dstend);
+
+
+path_type find_path_start_and_type(const char** src, int recurse, const char* end);
+void copy_to_dst(const char* from, const char* to, char** dst, const char* dstend);
+void convert_path(const char** from, const char* to, path_type type, char** dst, const char* dstend);
+
+//Transformations
+//SIMPLE_WINDOWS_PATH converter. Copy as is. Hold C:\Something\like\this
+void swp_convert(const char** from, const char* to, char** dst, const char* dstend);
+//ESCAPE_WINDOWS_PATH converter. Turn backslashes to slashes and skip first /. Hold /C:\Somethind\like\this
+void ewp_convert(const char** from, const char* to, char** dst, const char* dstend);
+//WINDOWS_PATH_LIST converter. Copy as is. Hold /something/like/this;
+void wpl_convert(const char** from, const char* to, char** dst, const char* dstend);
+//UNC convert converter. Copy as is. Hold //somethig/like/this
+void unc_convert(const char** from, const char* to, char** dst, const char* dstend);
+//ESCAPED_PATH converter. Turn backslashes to slashes and skip first /. Hold //something\like\this
+void ep_convert(const char** from, const char* to, char** dst, const char* dstend);
+//ROOTED_PATH converter. Prepend root dir to front. Hold /something/like/this
+void rp_convert(const char** from, const char* to, char** dst, const char* dstend);
+//URL converter. Copy as is.
+void url_convert(const char** from, const char* to, char** dst, const char* dstend);
+//POSIX_PATH_LIST. Hold x::x/y:z
+void ppl_convert(const char** from, const char* to, char** dst, const char* dstend);
+
+
+void find_end_of_posix_list(const char** to, int* in_string) {
+    for (; **to != '\0' && (!in_string || **to != *in_string); ++*to) {
+    }
+
+    if (**to == *in_string) {
+        *in_string = 0;
+    }
+}
+
+void find_end_of_rooted_path(const char** from, const char** to, int* in_string) {
+    for (const char* it = *from; *it != '\0' && it != *to; ++it)
+        if (*it == '.' && *(it + 1) == '.' && *(it - 1) == '/') {
+            *to = it - 1;
+            return;
+        }
+
+    for (; **to != '\0'; ++*to) {
+        if (*in_string == 0 && **to == ' ') {
+            return;
+        }
+
+        if (**to == *in_string) {
+            *in_string = 0;
+            return;
+        }
+
+        if (**to == '/') {
+            if (*(*to - 1) == ' ') {
+                *to -= 1;
+                return;
+            }
+        }
+    }
+}
+
+void sub_convert(const char** from, const char** to, char** dst, const char* dstend, int* in_string) {
+    const char* copy_from = *from;
+    path_type type = find_path_start_and_type(from, false, *to);
+    debug_printf("found type %d for path %s", type, copy_from);
+
+    if (type == POSIX_PATH_LIST) {
+        find_end_of_posix_list(to, in_string);
+    }
+
+    if (type == ROOTED_PATH) {
+        find_end_of_rooted_path(from, to, in_string);
+    }
+
+    copy_to_dst(copy_from, *from, dst, dstend);
+
+    if (type != NONE) {
+        convert_path(from, *to, type, dst, dstend);
+    }
+
+    if (*dst != dstend) {
+        **dst = **to;
+        *dst += 1;
+    }
+}
+
+const char* convert(char *dst, size_t dstlen, const char *src) {
+    if (dst == NULL || dstlen == 0 || src == NULL) {
+        return dst;
+    }
+
+    int need_convert = false;
+    for (const char* it = src; *it != '\0'; ++it) {
+        if (*it == '\\' || *it == '/') {
+            need_convert = true;
+            break;
+        }
+        if (isspace(*it)) {
+            need_convert = false;
+            break;
+        }
+    }
+
+    char* dstit = dst;
+    char* dstend = dst + dstlen;
+    if (!need_convert) {
+        copy_to_dst(src, NULL, &dstit, dstend);
+        *dstit = '\0';
+        return dst;
+    }
+    *dstend = '\0';
+
+    const char* srcit = src;
+    const char* srcbeg = src;
+
+    int in_string = false;
+
+    for (; *srcit != '\0'; ++srcit) {
+        if (*srcit == '\'' || *srcit == '"') {
+            if (in_string == *srcit) {
+                if (*(srcit + 1) != in_string) {
+                    in_string = 0;
+                }
+            } else {
+                in_string = *srcit;
+            }
+            continue;
+        }
+    }
+
+    sub_convert(&srcbeg, &srcit, &dstit, dstend, &in_string);
+    if (!*srcit) {
+      *dstit = '\0';
+      return dst;
+    }
+    srcbeg = srcit + 1;
+    for (; *srcit != '\0'; ++srcit) {
+      continue;
+    }
+    copy_to_dst(srcbeg, srcit, &dstit, dstend);
+    *dstit = '\0';
+
+    /*if (dstit - dst < 2) {
+        dstit = dst;
+        copy_to_dst(src, NULL, &dstit, dstend);
+        *dstit = '\0';
+    }*/
+
+    return dst;
+}
+
+void copy_to_dst(const char* from, const char* to, char** dst, const char* dstend) {
+    for (; (*from != '\0') && (from != to) && (*dst != dstend); ++from, ++(*dst)) {
+        **dst = *from;
+    }
+}
+
+const char** move(const char** p, int count) {
+    *p += count;
+    return p;
+}
+
+path_type find_path_start_and_type(const char** src, int recurse, const char* end) {
+    const char* it = *src;
+
+    if (*it == '\0' || it == end) return NONE;
+
+    /* Let's not convert ~/.file to ~C:\msys64\.file */
+    if (*it == '~') {
+skip_p2w:
+        *src = end;
+        return NONE;
+    }
+
+    /*
+     * Prevent Git's :file.txt and :/message syntax from beeing modified.
+     */
+    if (*it == ':')
+        goto skip_p2w;
+
+    while (it != end && *it) {
+        switch (*it) {
+        case '`':
+        case '\'':
+        case '*':
+        case '?':
+        case '[':
+        case ']':
+            goto skip_p2w;
+        case '/':
+            if (it + 1 < end && it[1] == '~')
+                goto skip_p2w;
+            break;
+        case ':':
+            // Avoid mangling IPv6 addresses
+            if (it + 1 < end && it[1] == ':')
+                goto skip_p2w;
+
+            // Leave Git's <rev>:./name syntax alone
+            if (it + 1 < end && it[1] == '.') {
+                if (it + 2 < end && it[2] == '/')
+                    goto skip_p2w;
+                if (it + 3 < end && it[2] == '.' && it[3] == '/')
+                    goto skip_p2w;
+            }
+            break;
+        case '@':
+            // Paths do not contain '@@'
+            if (it + 1 < end && it[1] == '@')
+                goto skip_p2w;
+        }
+        ++it;
+    }
+    it = *src;
+
+    while (!isalnum(*it) && *it != '/' && *it != '\\' && *it != ':' && *it != '-' && *it != '.') {
+        recurse = true;
+        it = ++*src;
+        if (it == end || *it == '\0') return NONE;
+    }
+
+    path_type result = NONE;
+
+    if (it + 1 == end) {
+        switch (*it) {
+        case '/':   return ROOTED_PATH ;
+        default:    return SIMPLE_WINDOWS_PATH;
+        }
+    }
+
+    if (isalpha(*it) && *(it + 1) == ':') {
+        if (*(it + 2) == '\\') {
+            return SIMPLE_WINDOWS_PATH;
+        }
+
+        if (*(it + 2) == '/' && memchr(it + 2, ':', end - (it + 2)) == NULL) {
+            return SIMPLE_WINDOWS_PATH;
+        }
+
+        if (*(it + 2) == '/' && memchr(it + 2, ';', end - (it + 2))) {
+            return WINDOWS_PATH_LIST;
+        }
+    }
+
+    if (*it == '.' && (*(it + 1) == '.' || *(it + 1) == '/') && memchr(it + 2, ':', end - (it + 2)) == NULL) {
+        return RELATIVE_PATH;
+    }
+
+    if (*it == '/') {
+        it += 1;
+
+        if (isalpha(*it) && *(it + 1) == ':') {
+            return ESCAPE_WINDOWS_PATH;
+        }
+
+        if (*it == '.' && *(it + 1) == '.') {
+            return SIMPLE_WINDOWS_PATH;
+        }
+
+        if (*it == '/') {
+            it += 1;
+            switch(*it) {
+              case ':': return URL;
+              case '/': return ESCAPED_PATH;
+            }
+            if (memchr(it, '/', end - it))
+              return UNC;
+            else
+              return ESCAPED_PATH;
+        }
+
+        for (; *it != '\0' && it != end; ++it) {
+            switch(*it) {
+                case ':': {char ch = *(it + 1); if (ch == '/' || ch == ':' || ch == '.') return POSIX_PATH_LIST;} return WINDOWS_PATH_LIST;
+                case ';': return WINDOWS_PATH_LIST;
+            }
+        }
+
+        if (result != NONE) {
+            return result;
+        }
+
+        return ROOTED_PATH;
+    }
+
+    int starts_with_minus = 0;
+    int starts_with_minus_alpha = 0;
+    int only_dots = *it == '.';
+    int has_slashes = 0;
+    if (*it == '-') {
+      starts_with_minus = 1;
+      it += 1;
+      if (isalpha(*it)) {
+        it += 1;
+        starts_with_minus_alpha = 1;
+        if (memchr(it, ';', end - it)) {
+        	return WINDOWS_PATH_LIST;
+        }
+      }
+    }
+
+    for (const char* it2 = it; *it2 != '\0' && it2 != end; ++it2) {
+        char ch = *it2;
+        if (starts_with_minus_alpha) {
+            if (isalpha(ch) && (*(it2+1) == ':') && (*(it2+2) == '/')) {
+                return SIMPLE_WINDOWS_PATH;
+            }
+            if (ch == '/'&& memchr(it2, ',', end - it2) == NULL) {
+                *src = it2;
+                return find_path_start_and_type(src, true, end);
+            }
+            starts_with_minus_alpha = 0;
+        }
+        if (ch == '\'' || ch == '"')
+            starts_with_minus = false;
+        if ((ch == '=') || (ch == ':' && starts_with_minus) || ((ch == '\'' || ch == '"') && result == NONE)) {
+            *src = it2 + 1;
+            return find_path_start_and_type(src, true, end);
+        }
+
+        if (ch == ',' && starts_with_minus) {
+            *src = it2 + 1;
+            return find_path_start_and_type(src, true, end);
+        }
+
+        if (ch == ':' && it2 + 1 != end) {
+            it2 += 1;
+            ch = *it2;
+            if (ch == '/' || ch == ':' || ch == '.') {
+                if (ch == '/' && *(it2 + 1) == '/') {
+                    return URL;
+                } else {
+                    if (!only_dots && !has_slashes)
+                        goto skip_p2w;
+                    return POSIX_PATH_LIST;
+                }
+            } else if (memchr(it2, '=', end - it2) == NULL) {
+                return SIMPLE_WINDOWS_PATH;
+            }
+        } else if (ch != '.') {
+            only_dots = 0;
+            if (ch == '/' || ch == '\\')
+                has_slashes = 1;
+        }
+    }
+
+    if (result != NONE) {
+        *src = it;
+        return result;
+    }
+
+    return SIMPLE_WINDOWS_PATH;
+}
+
+void convert_path(const char** from, const char* to, path_type type, char** dst, const char* dstend) {
+    switch(type) {
+        case SIMPLE_WINDOWS_PATH: swp_convert(from, to, dst, dstend); break;
+        case ESCAPE_WINDOWS_PATH: ewp_convert(from, to, dst, dstend); break;
+        case WINDOWS_PATH_LIST: wpl_convert(from, to, dst, dstend); break;
+        case RELATIVE_PATH: swp_convert(from, to, dst, dstend); break;
+        case UNC: unc_convert(from, to, dst, dstend); break;
+        case ESCAPED_PATH: ep_convert(from, to, dst, dstend); break;
+        case ROOTED_PATH: rp_convert(from, to, dst, dstend); break;
+        case URL: url_convert(from, to, dst, dstend); break;
+        case POSIX_PATH_LIST: ppl_convert(from, to, dst, dstend); break;
+        case NONE: // prevent warnings;
+        default:
+                return;
+    }
+}
+
+void swp_convert(const char** from, const char* to, char** dst, const char* dstend) {
+    copy_to_dst(*from, to, dst, dstend);
+}
+
+void ewp_convert(const char** from, const char* to, char** dst, const char* dstend) {
+    *from += 1;
+    unc_convert(from, to, dst, dstend);
+}
+
+void wpl_convert(const char** from, const char* to, char** dst, const char* dstend) {
+    swp_convert(from, to, dst, dstend);
+}
+
+void unc_convert(const char** from, const char* to, char** dst, const char* dstend) {
+    const char* it = *from;
+    for (; (*it != '\0' && it != to) && (*dst != dstend); ++it, ++(*dst)) {
+        if (*it == '\\') {
+            **dst = '/';
+        } else {
+            **dst = *it;
+        }
+    }
+}
+
+void ep_convert(const char** from, const char* to, char** dst, const char* dstend) {
+    ewp_convert(from, to, dst, dstend);
+}
+
+void rp_convert(const char** from, const char* to, char** dst, const char* dstend) {
+    const char* it = *from;
+    const char* real_to = to;
+
+    if (*real_to == '\0')  {
+        real_to -= 1;
+        if (*real_to != '\'' && *real_to != '"') {
+            real_to += 1;
+        }
+    }
+
+    if (!is_special_posix_path(*from, real_to, dst, dstend)) {
+        posix_to_win32_path(it, real_to, dst, dstend);
+    }
+
+    if (*dst != dstend && real_to != to) {
+        **dst = *real_to;
+        *dst += 1;
+    }
+}
+
+void url_convert(const char** from, const char* to, char** dst, const char* dstend) {
+    unc_convert(from, to, dst, dstend);
+}
+
+void subp_convert(const char** from, const char* end, int is_url, char** dst, const char* dstend) {
+    const char* begin = *from;
+    path_type type = is_url ? URL : find_path_start_and_type(from, 0, end);
+    copy_to_dst(begin, *from, dst, dstend);
+
+    if (type == NONE) {
+        return;
+    }
+
+    char* start = *dst;
+    convert_path(from, end, type, dst, dstend);
+
+    if (!is_url) {
+        for (; start != *dst; ++start) {
+            if (*start == '/') {
+                *start = '\\';
+            }
+        }
+    }
+}
+
+void ppl_convert(const char** from, const char* to, char** dst, const char* dstend) {
+    const char *orig_dst = *dst;
+    const char* it = *from;
+    const char* beg = it;
+    int prev_was_simc = 0;
+    int is_url = 0;
+    for (; (*it != '\0' && it != to) && (*dst != dstend); ++it) {
+        if (*it == ':') {
+            if (prev_was_simc) {
+                continue;
+            }
+            if (*(it + 1) == '/' && *(it + 2) == '/' && isalpha(*beg)) {
+                is_url = 1;
+                /* double-check: protocol must be alnum (or +) */
+                for (const char *p = beg; p != it; ++p)
+                    if (!isalnum(*p) && *p != '+') {
+                        is_url = 0;
+                        break;
+                    }
+                if (is_url)
+                    continue;
+            }
+            prev_was_simc = 1;
+            subp_convert(&beg, it, is_url, dst, dstend);
+            is_url = 0;
+
+            if (*dst == dstend) {
+                system_printf("Path cut off during conversion: %s\n", orig_dst);
+                break;
+            }
+
+            **dst = ';';
+            *dst += 1;
+        }
+
+        if (*it != ':' && prev_was_simc) {
+            prev_was_simc = 0;
+            beg = it;
+        }
+    }
+
+    if (!prev_was_simc) {
+        subp_convert(&beg, it, is_url, dst, dstend);
+    }
+}
+
+int is_special_posix_path(const char* from, const char* to, char** dst, const char* dstend) {
+    const char dev_null[] = "/dev/null";
+
+    if ((to - from) == (sizeof(dev_null) - 1) && strncmp(from, "/dev/null", to - from) == 0) {
+        copy_to_dst("nul", NULL, dst, dstend);
+        return true;
+    }
+    return false;
+}
+
+void posix_to_win32_path(const char* from, const char* to, char** dst, const char* dstend) {
+    if ( from != to ) {
+        tmp_pathbuf tp;
+        char *one_path = tp.c_get();
+        strncpy(one_path, from, to-from);
+        one_path[to-from] = '\0';
+
+        path_conv conv (one_path, 0);
+        if (conv.error)
+        {
+          set_errno(conv.error);
+          copy_to_dst(one_path, NULL, dst, dstend);
+        } else {
+          char* win32_path = tp.c_get();
+          stpcpy (win32_path, conv.get_win32 ());
+          for (; (*win32_path != '\0') && (*dst != dstend); ++win32_path, ++(*dst)) {
+             **dst = (*win32_path == '\\') ? '/' : *win32_path;
+          }
+        }
+    }
+}
+
diff --git a/winsup/cygwin/msys2_path_conv.h b/winsup/cygwin/msys2_path_conv.h
new file mode 100644
index 0000000000..67d85ecb64
--- /dev/null
+++ b/winsup/cygwin/msys2_path_conv.h
@@ -0,0 +1,147 @@
+/*
+  The MSYS2 Path conversion source code is licensed under:
+  
+  CC0 1.0 Universal
+  
+  Official translations of this legal tool are available
+  
+  CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+  LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+  ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+  INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+  REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+  PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+  THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+  HEREUNDER.
+  
+  Statement of Purpose
+  
+  The laws of most jurisdictions throughout the world automatically
+  confer exclusive Copyright and Related Rights (defined below) upon the
+  creator and subsequent owner(s) (each and all, an "owner") of an
+  original work of authorship and/or a database (each, a "Work").
+  
+  Certain owners wish to permanently relinquish those rights to a Work
+  for the purpose of contributing to a commons of creative, cultural and
+  scientific works ("Commons") that the public can reliably and without
+  fear of later claims of infringement build upon, modify, incorporate
+  in other works, reuse and redistribute as freely as possible in any
+  form whatsoever and for any purposes, including without limitation
+  commercial purposes. These owners may contribute to the Commons to
+  promote the ideal of a free culture and the further production of
+  creative, cultural and scientific works, or to gain reputation or
+  greater distribution for their Work in part through the use and
+  efforts of others.
+  
+  For these and/or other purposes and motivations, and without any
+  expectation of additional consideration or compensation, the person
+  associating CC0 with a Work (the "Affirmer"), to the extent that he or
+  she is an owner of Copyright and Related Rights in the Work,
+  voluntarily elects to apply CC0 to the Work and publicly distribute
+  the Work under its terms, with knowledge of his or her Copyright and
+  Related Rights in the Work and the meaning and intended legal effect
+  of CC0 on those rights.
+  
+  1. Copyright and Related Rights. A Work made available under CC0 may
+  be protected by copyright and related or neighboring rights
+  ("Copyright and Related Rights"). Copyright and Related Rights
+  include, but are not limited to, the following:
+  
+  the right to reproduce, adapt, distribute, perform, display,
+  communicate, and translate a Work;
+  moral rights retained by the original author(s) and/or performer(s);
+  publicity and privacy rights pertaining to a person's image or
+  likeness depicted in a Work;
+  rights protecting against unfair competition in regards to a Work,
+  subject to the limitations in paragraph 4(a), below;
+  rights protecting the extraction, dissemination, use and reuse of data
+  in a Work;
+  database rights (such as those arising under Directive 96/9/EC of the
+  European Parliament and of the Council of 11 March 1996 on the legal
+  protection of databases, and under any national implementation
+  thereof, including any amended or successor version of such
+  directive); and
+  other similar, equivalent or corresponding rights throughout the world
+  based on applicable law or treaty, and any national implementations
+  thereof.
+  
+  2. Waiver. To the greatest extent permitted by, but not in
+  contravention of, applicable law, Affirmer hereby overtly, fully,
+  permanently, irrevocably and unconditionally waives, abandons, and
+  surrenders all of Affirmer's Copyright and Related Rights and
+  associated claims and causes of action, whether now known or unknown
+  (including existing as well as future claims and causes of action), in
+  the Work (i) in all territories worldwide, (ii) for the maximum
+  duration provided by applicable law or treaty (including future time
+  extensions), (iii) in any current or future medium and for any number
+  of copies, and (iv) for any purpose whatsoever, including without
+  limitation commercial, advertising or promotional purposes (the
+  "Waiver"). Affirmer makes the Waiver for the benefit of each member of
+  the public at large and to the detriment of Affirmer's heirs and
+  successors, fully intending that such Waiver shall not be subject to
+  revocation, rescission, cancellation, termination, or any other legal
+  or equitable action to disrupt the quiet enjoyment of the Work by the
+  public as contemplated by Affirmer's express Statement of Purpose.
+  
+  3. Public License Fallback. Should any part of the Waiver for any
+  reason be judged legally invalid or ineffective under applicable law,
+  then the Waiver shall be preserved to the maximum extent permitted
+  taking into account Affirmer's express Statement of Purpose. In
+  addition, to the extent the Waiver is so judged Affirmer hereby grants
+  to each affected person a royalty-free, non transferable, non
+  sublicensable, non exclusive, irrevocable and unconditional license to
+  exercise Affirmer's Copyright and Related Rights in the Work (i) in
+  all territories worldwide, (ii) for the maximum duration provided by
+  applicable law or treaty (including future time extensions), (iii) in
+  any current or future medium and for any number of copies, and (iv)
+  for any purpose whatsoever, including without limitation commercial,
+  advertising or promotional purposes (the "License"). The License shall
+  be deemed effective as of the date CC0 was applied by Affirmer to the
+  Work. Should any part of the License for any reason be judged legally
+  invalid or ineffective under applicable law, such partial invalidity
+  or ineffectiveness shall not invalidate the remainder of the License,
+  and in such case Affirmer hereby affirms that he or she will not (i)
+  exercise any of his or her remaining Copyright and Related Rights in
+  the Work or (ii) assert any associated claims and causes of action
+  with respect to the Work, in either case contrary to Affirmer's
+  express Statement of Purpose.
+  
+  4. Limitations and Disclaimers.
+  
+  No trademark or patent rights held by Affirmer are waived, abandoned,
+  surrendered, licensed or otherwise affected by this document.
+  Affirmer offers the Work as-is and makes no representations or
+  warranties of any kind concerning the Work, express, implied,
+  statutory or otherwise, including without limitation warranties of
+  title, merchantability, fitness for a particular purpose, non
+  infringement, or the absence of latent or other defects, accuracy, or
+  the present or absence of errors, whether or not discoverable, all to
+  the greatest extent permissible under applicable law.
+  Affirmer disclaims responsibility for clearing rights of other persons
+  that may apply to the Work or any use thereof, including without
+  limitation any person's Copyright and Related Rights in the Work.
+  Further, Affirmer disclaims responsibility for obtaining any necessary
+  consents, permissions or other rights required for any use of the
+  Work.
+  Affirmer understands and acknowledges that Creative Commons is not a
+  party to this document and has no duty or obligation with respect to
+  this CC0 or use of the Work.
+
+  Contributions thanks to:
+    niXman <i.nixman@autistici.org>
+    Ely Arzhannikov <iarzhannikov@gmail.com>
+    Alexey Pavlov <alexpux@gmail.com>
+    Ray Donnelly <mingw.android@gmail.com>
+    Johannes Schindelin <johannes.schindelin@gmx.de>
+  
+*/
+
+#ifndef PATH_CONV_H_DB4IQBH3
+#define PATH_CONV_H_DB4IQBH3
+
+#include <stdlib.h>
+
+const char* convert(char *dst, size_t dstlen, const char *src);
+
+#endif /* end of include guard: PATH_CONV_H_DB4IQBH3 */
+
diff --git a/winsup/cygwin/path.cc b/winsup/cygwin/path.cc
index 8aff97acbe..b758bc50ea 100644
--- a/winsup/cygwin/path.cc
+++ b/winsup/cygwin/path.cc
@@ -66,6 +66,7 @@
 #include "shared_info.h"
 #include "tls_pbuf.h"
 #include "environ.h"
+#include "msys2_path_conv.h"
 #undef basename
 
 suffix_info stat_suffixes[] =
@@ -3898,6 +3899,74 @@ fchdir (int fd)
   return res;
 }
 
+//
+// Important: If returned pointer == arg, then this function
+//            did not malloc that pointer; otherwise free it.
+//
+extern "C" char *
+arg_heuristic_with_exclusions (char const * const arg, char const * exclusions, size_t exclusions_count)
+{
+  char *arg_result;
+
+  // Must return something ..
+  size_t arglen = (arg ? strlen (arg): 0);
+  
+  if (arglen == 0 || !arg)
+  {
+    arg_result = (char *)malloc (sizeof (char));
+    arg_result[0] = '\0';
+    return arg_result;
+  }
+
+  debug_printf("Input value: (%s)", arg);
+  for (size_t excl = 0; excl < exclusions_count; ++excl)
+    {
+      /* Since we've got regex linked we should maybe switch to that, but
+         running regexes for every argument could be too slow. */
+      if ( strcmp (exclusions, "*") == 0 || (strlen (exclusions) && strstr (arg, exclusions) == arg) )
+        return (char*)arg;
+      exclusions += strlen (exclusions) + 1;
+    }
+
+  // Leave enough room for at least 16 path elements; we might be converting
+  // a path list.
+  size_t stack_len = arglen + 16 * MAX_PATH;
+  char * stack_path = (char *)malloc (stack_len);
+  if (!stack_path)
+    {
+      debug_printf ("out of stack space?");
+      return (char *)arg;
+    }
+  memset (stack_path, 0, MAX_PATH);
+  convert (stack_path, stack_len - 1, arg);
+  debug_printf ("convert()'ed: %s (length %d)\n.....->: %s", arg, arglen, stack_path);
+  // Don't allocate memory if no conversion happened.
+  if (!strcmp (arg, stack_path))
+    {
+      if (arg != stack_path)
+        {
+          free (stack_path);
+        }
+      return ((char *)arg);
+    }
+  arg_result = (char *)realloc (stack_path, strlen (stack_path)+1);
+  // Windows doesn't like empty entries in PATH env. variables (;;)
+  char* semisemi = strstr(arg_result, ";;");
+  while (semisemi)
+    {
+      memmove(semisemi, semisemi+1, strlen(semisemi));
+      semisemi = strstr(semisemi, ";;");
+    }
+  return arg_result;
+}
+
+extern "C" char *
+arg_heuristic (char const * const arg)
+{
+  return arg_heuristic_with_exclusions (arg, NULL, 0);
+}
+
+
 /******************** Exported Path Routines *********************/
 
 /* Cover functions to the path conversion routines.
diff --git a/winsup/cygwin/spawn.cc b/winsup/cygwin/spawn.cc
index 71add8755c..785586af6d 100644
--- a/winsup/cygwin/spawn.cc
+++ b/winsup/cygwin/spawn.cc
@@ -286,6 +286,27 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
   bool rc;
   int res = -1;
 
+  /* Environment variable MSYS2_ARG_CONV_EXCL contains a list
+     of ';' separated argument prefixes to pass un-modified..
+     It isn't applied to env. variables; only spawn arguments.
+     A value of * means don't convert any arguments. */
+  char* msys2_arg_conv_excl_env = getenv("MSYS2_ARG_CONV_EXCL");
+  char* msys2_arg_conv_excl = NULL;
+  size_t msys2_arg_conv_excl_count = 0;
+  if (msys2_arg_conv_excl_env)
+    {
+      msys2_arg_conv_excl = (char*)alloca (strlen(msys2_arg_conv_excl_env)+1);
+      strcpy (msys2_arg_conv_excl, msys2_arg_conv_excl_env);
+      msys2_arg_conv_excl_count = 1;
+      msys2_arg_conv_excl_env = strchr ( msys2_arg_conv_excl, ';' );
+      while (msys2_arg_conv_excl_env)
+        {
+          *msys2_arg_conv_excl_env = '\0';
+          ++msys2_arg_conv_excl_count;
+          msys2_arg_conv_excl_env = strchr ( msys2_arg_conv_excl_env + 1, ';' );
+        }
+    }
+
   /* Check if we have been called from exec{lv}p or spawn{lv}p and mask
      mode to keep only the spawn mode. */
   bool p_type_exec = !!(mode & _P_PATH_TYPE_EXEC);
@@ -377,6 +398,20 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
 	  moreinfo->argc = newargv.argc;
 	  moreinfo->argv = newargv;
 	}
+      else
+	{
+	  for (int i = 0; i < newargv.argc; i++)
+	    {
+	      //convert argv to win32
+	      int newargvlen = strlen (newargv[i]);
+	      char *tmpbuf = (char *)malloc (newargvlen + 1);
+	      memcpy (tmpbuf, newargv[i], newargvlen + 1);
+	      tmpbuf = arg_heuristic_with_exclusions(tmpbuf, msys2_arg_conv_excl, msys2_arg_conv_excl_count);
+	      debug_printf("newargv[%d] = %s", i, newargv[i]);
+	      newargv.replace (i, tmpbuf);
+	      free (tmpbuf);
+	    }
+	}
       if ((wincmdln || !real_path.iscygexec ())
 	   && !cmd.fromargv (newargv, real_path.get_win32 (),
 			     real_path.iscygexec ()))
@@ -507,7 +542,8 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
       moreinfo->envp = build_env (envp, envblock, moreinfo->envc,
 				  real_path.iscygexec (),
 				  switch_user ? ::cygheap->user.primary_token ()
-					      : NULL);
+					      : NULL,
+				  real_path.iscygexec ());
       if (!moreinfo->envp || !envblock)
 	{
 	  set_errno (E2BIG);

From 4b92ba68de4def343faf23dc1858275c4a8115fc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B5=D0=B8=CC=86=20=D0=9F?=
 =?UTF-8?q?=D0=B0=D0=B2=D0=BB=D0=BE=D0=B2?= <alexey.pawlow@gmail.com>
Date: Sun, 14 Apr 2019 21:29:01 +0300
Subject: [PATCH 24/84] Add functionality for changing OS name via MSYSTEM
 environment variables.

---
 winsup/cygserver/cygserver-config   |  4 ++--
 winsup/cygwin/environ.cc            | 34 ++++++++++++++++++++++++++---
 winsup/cygwin/include/sys/utsname.h |  2 +-
 winsup/cygwin/uname.cc              | 17 +++++++++++++--
 4 files changed, 49 insertions(+), 8 deletions(-)

diff --git a/winsup/cygserver/cygserver-config b/winsup/cygserver/cygserver-config
index abda186449..1f0603f68c 100755
--- a/winsup/cygserver/cygserver-config
+++ b/winsup/cygserver/cygserver-config
@@ -86,7 +86,7 @@ done
 
 # Check if running on NT
 _sys="`uname`"
-_nt=`expr "${_sys}" : "CYGWIN_NT"`
+_nt=`expr "${_sys}" : "MSYS_NT"`
 
 # Check for running cygserver processes first.
 if ps -e | grep -v grep | grep -q ${service_name}
@@ -178,7 +178,7 @@ then
     echo "Do you want to install cygserver as service?"
     if request "(Say \"no\" if it's already installed as service)"
     then
-      if ! cygrunsrv -I ${service_name} -d "CYGWIN cygserver" -p /usr/sbin/cygserver
+      if ! cygrunsrv -I ${service_name} -d "MSYS cygserver" -p /usr/sbin/cygserver
       then
         echo
 	echo "Installation of cygserver as service failed.  Please check the"
diff --git a/winsup/cygwin/environ.cc b/winsup/cygwin/environ.cc
index 639e69393b..b9f7e05452 100644
--- a/winsup/cygwin/environ.cc
+++ b/winsup/cygwin/environ.cc
@@ -192,7 +192,11 @@ parse_options (const char *inbuf)
       if (export_settings)
 	{
 	  debug_printf ("%s", newbuf + 1);
+#ifdef __MSYS__
+	  setenv ("MSYS", newbuf + 1, 1);
+#else
 	  setenv ("CYGWIN", newbuf + 1, 1);
+#endif
 	}
       return;
     }
@@ -651,7 +655,7 @@ _addenv (const char *name, const char *value, int overwrite)
   win_env *spenv;
   if ((spenv = getwinenv (envhere)))
     spenv->add_cache (value);
-  if (strcmp (name, "CYGWIN") == 0)
+  if (strcmp (name, "MSYS") == 0)
     parse_options (value);
 
   return 0;
@@ -754,6 +758,9 @@ static struct renv {
 } renv_arr[] = {
 	{ NL("COMMONPROGRAMFILES=") },		// 0
 	{ NL("COMSPEC=") },
+#ifdef __MSYS__
+	{ NL("MSYSTEM=") },			// 2
+#endif /* __MSYS__ */
 	{ NL("PATH=") },			// 2
 	{ NL("PROGRAMFILES=") },
 	{ NL("SYSTEMDRIVE=") },			// 4
@@ -765,10 +772,21 @@ static struct renv {
 #define RENV_SIZE (sizeof (renv_arr) / sizeof (renv_arr[0]))
 
 /* Set of first characters of the above list of variables. */
-static const char idx_arr[] = "CPSTW";
+static const char idx_arr[] =
+#ifdef __MSYS__
+	"CMPSTW";
+#else
+	"CPSTW";
+#endif
 /* Index into renv_arr at which the variables with this specific character
    starts. */
-static const int start_at[] = { 0, 2, 4, 6, 8 };
+static const int start_at[] = {
+#ifdef __MSYS__
+				0, 2, 3, 5, 7, 9
+#else
+				0, 2, 4, 6, 8
+#endif
+								};
 
 /* Turn environment variable part of a=b string into uppercase - for some
    environment variables only. */
@@ -836,7 +854,11 @@ environ_init (char **envp, int envc)
       dumper_init ();
       if (envp_passed_in)
 	{
+#ifdef __MSYS__
+	  p = getenv ("MSYS");
+#else
 	  p = getenv ("CYGWIN");
+#endif
 	  if (p)
 	    parse_options (p);
 	}
@@ -883,8 +905,13 @@ win32env_to_cygenv (PWCHAR rawenv, bool posify)
       ucenv (newp, eq);    /* uppercase env vars which need it */
       if (*newp == 'T' && strncmp (newp, "TERM=", 5) == 0)
         sawTERM = 1;
+#ifdef __MSYS__
+      else if (*newp == 'M' && strncmp (newp, "MSYS=", 5) == 0)
+        parse_options (newp + 5);
+#else
       else if (*newp == 'C' && strncmp (newp, "CYGWIN=", 7) == 0)
         parse_options (newp + 7);
+#endif
       if (*eq && posify)
         posify_maybe (envp + i, *++eq ? eq : --eq, tmpbuf);
       debug_printf ("%p: %s", envp[i], envp[i]);
@@ -959,6 +986,7 @@ static NO_COPY spenv spenvs[] =
   {NL ("HOMEPATH="), false, false, &cygheap_user::env_homepath},
   {NL ("LOGONSERVER="), false, false, &cygheap_user::env_logsrv},
   {NL ("PATH="), false, true, NULL},
+  {NL ("MSYSTEM="), true, true, NULL},
   {NL ("SYSTEMDRIVE="), false, true, NULL},
   {NL ("SYSTEMROOT="), true, true, &cygheap_user::env_systemroot},
   {NL ("USERDOMAIN="), false, false, &cygheap_user::env_domain},
diff --git a/winsup/cygwin/include/sys/utsname.h b/winsup/cygwin/include/sys/utsname.h
index d6b3be96f7..730cb731a5 100644
--- a/winsup/cygwin/include/sys/utsname.h
+++ b/winsup/cygwin/include/sys/utsname.h
@@ -17,7 +17,7 @@ extern "C" {
 
 struct utsname
 {
-  char sysname[_UTSNAME_LENGTH];
+  char sysname[_UTSNAME_LENGTH + 1];
   char nodename[_UTSNAME_LENGTH];
   char release[_UTSNAME_LENGTH];
   char version[_UTSNAME_LENGTH];
diff --git a/winsup/cygwin/uname.cc b/winsup/cygwin/uname.cc
index c08e30f97d..ed4c9c59a1 100644
--- a/winsup/cygwin/uname.cc
+++ b/winsup/cygwin/uname.cc
@@ -37,7 +37,12 @@ uname_x (struct utsname *name)
 
       memset (name, 0, sizeof (*name));
       /* sysname */
-      n = __small_sprintf (name->sysname, "CYGWIN_%s-%u",
+      char* msystem = getenv("MSYSTEM");
+      const char* msystem_sysname = "MSYS";
+      if (msystem != NULL && *msystem && strcmp(msystem, "MSYS") != 0)
+        msystem_sysname = (strstr(msystem, "32") != NULL) ? "MINGW32" : "MINGW64";;
+      n = __small_sprintf (name->sysname, "%s_%s-%u",
+			   msystem_sysname,
 			   wincap.osname (), wincap.build_number ());
       if (wincap.host_machine () != wincap.cygwin_machine ())
 	{
@@ -104,7 +109,7 @@ uname_x (struct utsname *name)
 /* Old entrypoint for applications up to API 334 */
 struct old_utsname
 {
-  char sysname[20];
+  char sysname[21];
   char nodename[20];
   char release[20];
   char version[20];
@@ -118,7 +123,15 @@ uname (struct utsname *in_name)
   __try
     {
       memset (name, 0, sizeof (*name));
+#ifdef __MSYS__
+      char* msystem = getenv("MSYSTEM");
+      const char* msystem_sysname = "MSYS";
+      if (msystem != NULL && *msystem && strcmp(msystem, "MSYS") != 0)
+        msystem_sysname = (strstr(msystem, "32") != NULL) ? "MINGW32" : "MINGW64";
+      __small_sprintf (name->sysname, "%s_%s", msystem_sysname, wincap.osname ());
+#else
       __small_sprintf (name->sysname, "CYGWIN_%s", wincap.osname ());
+#endif
 
       /* Computer name */
       cygwin_gethostname (name->nodename, sizeof (name->nodename) - 1);

From c2e033e25d220b9aac43cbc73c4e4f6ec7d41d5a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B5=D0=B8=CC=86=20=D0=9F?=
 =?UTF-8?q?=D0=B0=D0=B2=D0=BB=D0=BE=D0=B2?= <alexey.pawlow@gmail.com>
Date: Sun, 14 Apr 2019 21:45:06 +0300
Subject: [PATCH 25/84] - Move root to /usr. - Change sorting mount points. -
 By default mount without ACLs. - Can read /etc/fstab with short mount point
 format.

---
 winsup/cygwin/local_includes/mount.h |   3 +-
 winsup/cygwin/mm/cygheap.cc          |  12 +-
 winsup/cygwin/mount.cc               | 185 +++++++++++++++++++++++----
 winsup/cygwin/uinfo.cc               |   2 +-
 4 files changed, 174 insertions(+), 28 deletions(-)

diff --git a/winsup/cygwin/local_includes/mount.h b/winsup/cygwin/local_includes/mount.h
index 163b47551f..15e9a342ba 100644
--- a/winsup/cygwin/local_includes/mount.h
+++ b/winsup/cygwin/local_includes/mount.h
@@ -173,7 +173,6 @@ class mount_info
   mount_item mount[MAX_MOUNTS];
 
   static bool got_usr_bin;
-  static bool got_usr_lib;
   static int root_idx;
 
   /* cygdrive_prefix is used as the root of the path automatically
@@ -185,6 +184,8 @@ class mount_info
  private:
   int posix_sorted[MAX_MOUNTS];
   int native_sorted[MAX_MOUNTS];
+  int longest_posix_sorted[MAX_MOUNTS];
+  int shortest_native_sorted[MAX_MOUNTS];
 
  public:
   void init (bool);
diff --git a/winsup/cygwin/mm/cygheap.cc b/winsup/cygwin/mm/cygheap.cc
index 1c9b8037b2..4a60995c44 100644
--- a/winsup/cygwin/mm/cygheap.cc
+++ b/winsup/cygwin/mm/cygheap.cc
@@ -220,14 +220,22 @@ init_cygheap::init_installation_root ()
 
   /* Strip off last path component ("\\cygwin1.dll") */
   PWCHAR w = wcsrchr (installation_root_buf, L'\\');
+#ifdef __MSYS__
+  /* Back two folders to get root as we have all stuff in usr subfolder */
+  for (int i=1; i >=0; --i)
+  {
+#endif
   if (w)
     {
       *w = L'\0';
       w = wcsrchr (installation_root_buf, L'\\');
     }
   if (!w)
-    api_fatal ("Can't initialize Cygwin installation root dir.\n"
+    api_fatal ("Can't initialize MSYS2 installation root dir.\n"
 	       "Invalid DLL path");
+#ifdef __MSYS__
+  }
+#endif
 
   /* Copy result into installation_dir before stripping off "bin" dir and
      revert to Win32 path.  This path is added to the Windows environment
@@ -252,6 +260,7 @@ init_cygheap::init_installation_root ()
   RtlInitUnicodeString (&installation_root, installation_root_buf);
   RtlInitUnicodeString (&installation_dir, installation_dir_buf);
 
+#ifndef __MSYS__
   for (int i = 1; i >= 0; --i)
     {
       reg_key r (i, KEY_WRITE, _WIDE (CYGWIN_INFO_INSTALLATIONS_NAME),
@@ -260,6 +269,7 @@ init_cygheap::init_installation_root ()
 				    installation_root_buf)))
 	break;
     }
+#endif
 }
 
 /* Initialize bucket_val.  The value is the max size of a block
diff --git a/winsup/cygwin/mount.cc b/winsup/cygwin/mount.cc
index 1cfee5c415..affb7e9266 100644
--- a/winsup/cygwin/mount.cc
+++ b/winsup/cygwin/mount.cc
@@ -42,7 +42,6 @@ details. */
   (path_prefix_p (proc, (path), proc_len, false))
 
 bool NO_COPY mount_info::got_usr_bin;
-bool NO_COPY mount_info::got_usr_lib;
 int NO_COPY mount_info::root_idx = -1;
 
 /* is_native_path: Return non-zero if PATH starts with \??\[a-zA-Z] or
@@ -395,7 +394,6 @@ fs_info::update (PUNICODE_STRING upath, HANDLE in_vol)
 #define MINIMAL_WIN_NTFS_FLAGS (FILE_CASE_SENSITIVE_SEARCH \
 				| FILE_CASE_PRESERVED_NAMES \
 				| FILE_UNICODE_ON_DISK \
-				| FILE_PERSISTENT_ACLS \
 				| FILE_FILE_COMPRESSION \
 				| FILE_VOLUME_QUOTAS \
 				| FILE_SUPPORTS_SPARSE_FILES \
@@ -552,13 +550,13 @@ mount_info::create_root_entry (const PWCHAR root)
   sys_wcstombs (native_root, PATH_MAX, root);
   assert (*native_root != '\0');
   if (add_item (native_root, "/",
-		MOUNT_SYSTEM | MOUNT_IMMUTABLE | MOUNT_AUTOMATIC)
+		MOUNT_SYSTEM | MOUNT_IMMUTABLE | MOUNT_AUTOMATIC | MOUNT_NOACL)
       < 0)
     api_fatal ("add_item (\"%s\", \"/\", ...) failed, errno %d", native_root, errno);
   /* Create a default cygdrive entry.  Note that this is a user entry.
      This allows to override it with mount, unless the sysadmin created
      a cygdrive entry in /etc/fstab. */
-  cygdrive_flags = MOUNT_NOPOSIX | MOUNT_CYGDRIVE;
+  cygdrive_flags = MOUNT_NOPOSIX | MOUNT_CYGDRIVE | MOUNT_NOACL;
   strcpy (cygdrive, CYGWIN_INFO_CYGDRIVE_DEFAULT_PREFIX "/");
   cygdrive_len = strlen (cygdrive);
 }
@@ -578,22 +576,14 @@ mount_info::init (bool user_init)
   pathend = wcpcpy (pathend, L"\\etc\\fstab");
   from_fstab (user_init, path, pathend);
 
-  if (!user_init && (!got_usr_bin || !got_usr_lib))
+  if (!user_init && !got_usr_bin)
     {
       char native[PATH_MAX];
       if (root_idx < 0)
-	api_fatal ("root_idx %d, user_shared magic %y, nmounts %d", root_idx, user_shared->version, nmounts);
+        api_fatal ("root_idx %d, user_shared magic %y, nmounts %d", root_idx, user_shared->version, nmounts);
       char *p = stpcpy (native, mount[root_idx].native_path);
-      if (!got_usr_bin)
-      {
-	stpcpy (p, "\\bin");
-	add_item (native, "/usr/bin", MOUNT_SYSTEM | MOUNT_AUTOMATIC);
-      }
-      if (!got_usr_lib)
-      {
-	stpcpy (p, "\\lib");
-	add_item (native, "/usr/lib", MOUNT_SYSTEM | MOUNT_AUTOMATIC);
-      }
+      stpcpy (p, "\\usr\\bin");
+      add_item (native, "/bin", MOUNT_SYSTEM | MOUNT_AUTOMATIC | MOUNT_NOACL);
     }
 }
 
@@ -674,6 +664,7 @@ mount_info::conv_to_win32_path (const char *src_path, char *dst, device& dev,
   /* See if this is a cygwin "device" */
   if (win32_device_name (src_path, dst, dev))
     {
+      debug_printf ("win32_device_name (%s)", src_path);
       *flags = 0;
       rc = 0;
       goto out_no_chroot_check;
@@ -711,6 +702,7 @@ mount_info::conv_to_win32_path (const char *src_path, char *dst, device& dev,
     }
   if (isproc (src_path))
     {
+      debug_printf ("isproc (%s)", src_path);
       dev = *proc_dev;
       dev = fhandler_proc::get_proc_fhandler (src_path);
       if (dev == FH_NADA)
@@ -732,6 +724,7 @@ mount_info::conv_to_win32_path (const char *src_path, char *dst, device& dev,
      off the prefix and transform it into an MS-DOS path. */
   else if (iscygdrive (src_path))
     {
+      debug_printf ("iscygdrive (%s) mount_table->cygdrive %s", src_path, mount_table->cygdrive);
       int n = mount_table->cygdrive_len - 1;
       int unit;
 
@@ -743,11 +736,15 @@ mount_info::conv_to_win32_path (const char *src_path, char *dst, device& dev,
 	}
       else if (cygdrive_win32_path (src_path, dst, unit))
 	{
+	  debug_printf ("cygdrive_win32_path (%s)", src_path);
 	  *flags = cygdrive_flags;
 	  goto out;
 	}
       else if (mount_table->cygdrive_len > 1)
-	return ENOENT;
+      {
+		debug_printf ("mount_table->cygdrive_len > 1 (%s)", src_path);
+		return ENOENT;
+      }
     }
 
   int chroot_pathlen;
@@ -758,7 +755,9 @@ mount_info::conv_to_win32_path (const char *src_path, char *dst, device& dev,
       const char *path;
       int len;
 
-      mi = mount + posix_sorted[i];
+      mi = mount + shortest_native_sorted[i];
+      debug_printf (" mount[%d] .. checking %s -> %s ", i, mi->posix_path, mi->native_path);
+
       if (!cygheap->root.exists ()
 	  || (mi->posix_pathlen == 1 && mi->posix_path[0] == '/'))
 	{
@@ -998,7 +997,8 @@ mount_info::conv_to_posix_path (const char *src_path, char *posix_path,
   int pathbuflen = tail - pathbuf;
   for (int i = 0; i < nmounts; ++i)
     {
-      mount_item &mi = mount[native_sorted[i]];
+      mount_item &mi = mount[longest_posix_sorted[i]];
+      debug_printf (" mount[%d] .. checking %s -> %s ", i, mi.posix_path, mi.native_path);
       if (!path_prefix_p (mi.native_path, pathbuf, mi.native_pathlen,
 			  mi.flags & MOUNT_NOPOSIX))
 	continue;
@@ -1211,8 +1211,17 @@ mount_info::from_fstab_line (char *line, bool user)
   if (!*c)
     return true;
   cend = find_ws (c);
-  *cend = '\0';
   posix_path = conv_fstab_spaces (c);
+  if (!*cend)
+   {
+     unsigned mount_flags = MOUNT_SYSTEM | MOUNT_NOPOSIX | MOUNT_NOACL;
+
+     int res = mount_table->add_item (native_path, posix_path, mount_flags);
+     if (res && get_errno () == EMFILE)
+       return false;
+     return true;
+   }
+  *cend = '\0';
   /* Third field: FS type. */
   c = skip_ws (cend + 1);
   if (!*c)
@@ -1441,16 +1450,145 @@ sort_by_native_name (const void *a, const void *b)
   return res;
 }
 
+/* sort_by_longest_posix_name: qsort callback to sort the mount entries.
+   Sort user mounts ahead of system mounts to the same POSIX path. */
+/* FIXME: should the user should be able to choose whether to
+   prefer user or system mounts??? */
+static int
+sort_by_longest_posix_name (const void *a, const void *b)
+{
+  mount_item *ap = mounts_for_sort + (*((int*) a));
+  mount_item *bp = mounts_for_sort + (*((int*) b));
+
+  /* Base weighting on the conversion that would give the longest
+     posix path. */
+  ssize_t alen = (ssize_t) strlen (ap->posix_path) - (ssize_t) strlen (ap->native_path);
+  ssize_t blen = (ssize_t) strlen (bp->posix_path) - (ssize_t) strlen (bp->native_path);
+
+  int res = blen - alen;
+
+  if (res)
+    return res;		/* Path lengths differed */
+
+  /* The two paths were the same length, so just determine normal
+     lexical sorted order. */
+  res = strcmp (ap->posix_path, bp->posix_path);
+
+  if (res == 0)
+   {
+     /* need to select between user and system mount to same POSIX path */
+     if (!(bp->flags & MOUNT_SYSTEM))	/* user mount */
+      return 1;
+     else
+      return -1;
+   }
+
+  return res;
+}
+
+/* sort_by_shortest_native_name: qsort callback to sort the mount entries.
+   Sort user mounts ahead of system mounts to the same POSIX path. */
+/* FIXME: should the user should be able to choose whether to
+   prefer user or system mounts??? */
+static int
+sort_by_shortest_native_name (const void *a, const void *b)
+{
+  mount_item *ap = mounts_for_sort + (*((int*) a));
+  mount_item *bp = mounts_for_sort + (*((int*) b));
+
+  /* Base weighting on the conversion that would give the shortest
+     native path. */
+  ssize_t alen = (ssize_t) strlen (ap->native_path);
+  ssize_t blen = (ssize_t) strlen (bp->native_path);
+
+  int res = alen - blen;
+
+  if (res)
+    return res;		/* Path lengths differed */
+
+  /* The two paths were the same length, so just determine normal
+     lexical sorted order. */
+  res = strcmp (ap->native_path, bp->native_path);
+
+  if (res == 0)
+   {
+     /* need to select between user and system mount to same POSIX path */
+     if (!(bp->flags & MOUNT_SYSTEM))	/* user mount */
+      return 1;
+     else
+      return -1;
+   }
+
+  return res;
+}
+
+static int
+sort_posix_subdirs_before_parents (const void *a, const void *b)
+{
+    mount_item *ap = mounts_for_sort + (*((int*) a));
+    mount_item *bp = mounts_for_sort + (*((int*) b));
+
+    if (ap->posix_pathlen > bp->posix_pathlen)
+    {
+        if (!memcmp (bp->posix_path, ap->posix_path, bp->posix_pathlen))
+        {
+            // bp is a subdir of ap (bp must be moved in-front)
+            return -1;
+        }
+    }
+    else if (ap->posix_pathlen < bp->posix_pathlen)
+    {
+        if (!memcmp (ap->posix_path, bp->posix_path, ap->posix_pathlen))
+        {
+            // ap is a subdir of bp (good as we are)
+            return 1;
+        }
+    }
+    return 0;
+}
+
+#define DISABLE_NEW_STUFF 0
+#define ONLY_USE_NEW_STUFF 1
+
 void
 mount_info::sort ()
 {
   for (int i = 0; i < nmounts; i++)
-    native_sorted[i] = posix_sorted[i] = i;
+    native_sorted[i] = posix_sorted[i] = shortest_native_sorted[i] = longest_posix_sorted[i] = i;
   /* Sort them into reverse length order, otherwise we won't
      be able to look for /foo in /.  */
   mounts_for_sort = mount;	/* ouch. */
   qsort (posix_sorted, nmounts, sizeof (posix_sorted[0]), sort_by_posix_name);
   qsort (native_sorted, nmounts, sizeof (native_sorted[0]), sort_by_native_name);
+  qsort (longest_posix_sorted, nmounts, sizeof (longest_posix_sorted[0]), sort_by_longest_posix_name);
+  qsort (shortest_native_sorted, nmounts, sizeof (shortest_native_sorted[0]), sort_by_shortest_native_name);
+  qsort (shortest_native_sorted, nmounts, sizeof (shortest_native_sorted[0]), sort_posix_subdirs_before_parents);
+  /* Disabling my new crap. */
+  #if DISABLE_NEW_STUFF
+  for (int i = 0; i < nmounts; i++)
+  {
+      longest_posix_sorted[i] = native_sorted[i];
+      shortest_native_sorted[i] = posix_sorted[i];
+  }
+  #else
+  #if ONLY_USE_NEW_STUFF
+  for (int i = 0; i < nmounts; i++)
+  {
+      native_sorted[i] = longest_posix_sorted[i];
+      posix_sorted[i] = shortest_native_sorted[i];
+  }
+  #endif
+  #endif
+  for (int i = 0; i < nmounts; i++)
+  {
+      mount_item *mi = mount + shortest_native_sorted[i];
+      debug_printf ("shortest_native_sorted (subdirs before parents)[%d] %12s       %12s", i, mi->native_path, mi->posix_path);
+  }
+  for (int i = 0; i < nmounts; i++)
+  {
+      mount_item *mi = mount + longest_posix_sorted[i];
+      debug_printf ("longest_posix_sorted[%d] %12s       %12s", i, mi->native_path, mi->posix_path);
+  }
 }
 
 /* Add an entry to the mount table.
@@ -1541,12 +1679,9 @@ mount_info::add_item (const char *native, const char *posix,
   if (i == nmounts)
     nmounts++;
 
-  if (strcmp (posixtmp, "/usr/bin") == 0)
+  if (strcmp (posixtmp, "/bin") == 0)
     got_usr_bin = true;
 
-  if (strcmp (posixtmp, "/usr/lib") == 0)
-    got_usr_lib = true;
-
   if (posixtmp[0] == '/' && posixtmp[1] == '\0' && !(mountflags & MOUNT_CYGDRIVE))
     root_idx = i;
 
diff --git a/winsup/cygwin/uinfo.cc b/winsup/cygwin/uinfo.cc
index ffe71ee072..4323cb1f6f 100644
--- a/winsup/cygwin/uinfo.cc
+++ b/winsup/cygwin/uinfo.cc
@@ -2811,7 +2811,7 @@ pwdgrp::fetch_account_from_windows (fetch_user_arg_t &arg, cyg_ldap *pldap)
 		     dom, name,
 		     sid.string ((char *) sidstr),
 		     home ?: "/home/", home ? L"" : name,
-		     shell ?: "/bin/bash");
+		     shell ?: "/usr/bin/bash");
   if (gecos)
     free (gecos);
   if (home)

From aaf1b29d8f4ca24846e3a69c0d6b3c96766baaeb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B5=D0=B8=CC=86=20=D0=9F?=
 =?UTF-8?q?=D0=B0=D0=B2=D0=BB=D0=BE=D0=B2?= <alexey.pawlow@gmail.com>
Date: Sun, 14 Apr 2019 21:47:21 +0300
Subject: [PATCH 26/84] Instead of creating Cygwin symlinks, use deep copy by
 default

The new `winsymlinks` mode `deepcopy` (which is made the default) lets
calls to `symlink()` create (deep) copies of the source file/directory.

This is necessary because unlike Cygwin, MSYS2 does not try to be its
own little ecosystem that lives its life separate from regular Win32
programs: the latter have _no idea_ about Cygwin-emulated symbolic links
(i.e. system files whose contents start with `!<symlink>\xff\xfe` and
the remainder consists of the NUL-terminated, UTF-16LE-encoded symlink
target).

To support Cygwin-style symlinks, the new mode `sysfile` is introduced.

Co-authored-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Co-authored-by: Jeremy Drake <github@jdrake.com>
---
 winsup/cygwin/environ.cc |   4 +
 winsup/cygwin/globals.cc |   3 +-
 winsup/cygwin/path.cc    | 252 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 258 insertions(+), 1 deletion(-)

diff --git a/winsup/cygwin/environ.cc b/winsup/cygwin/environ.cc
index b9f7e05452..5fb3f53ef5 100644
--- a/winsup/cygwin/environ.cc
+++ b/winsup/cygwin/environ.cc
@@ -88,6 +88,10 @@ set_winsymlinks (const char *buf)
   else if (ascii_strncasematch (buf, "native", 6))
     allow_winsymlinks = ascii_strcasematch (buf + 6, "strict")
 			? WSYM_nativestrict : WSYM_native;
+  else if (ascii_strncasematch (buf, "deepcopy", 8))
+    allow_winsymlinks = WSYM_deepcopy;
+  else
+    allow_winsymlinks = WSYM_sysfile;
 }
 
 /* The structure below is used to set up an array which is used to
diff --git a/winsup/cygwin/globals.cc b/winsup/cygwin/globals.cc
index d8e058f191..b7e0e21c52 100644
--- a/winsup/cygwin/globals.cc
+++ b/winsup/cygwin/globals.cc
@@ -57,6 +57,7 @@ enum winsym_t
   WSYM_nativestrict,
   WSYM_nfs,
   WSYM_sysfile,
+  WSYM_deepcopy
 };
 
 exit_states NO_COPY exit_state;
@@ -70,7 +71,7 @@ bool ignore_case_with_glob;
 bool pipe_byte = true; /* Default to byte mode so that C# programs work. */
 bool reset_com;
 bool wincmdln;
-winsym_t allow_winsymlinks = WSYM_default;
+winsym_t allow_winsymlinks = WSYM_deepcopy;
 bool disable_pcon;
 bool winjitdebug = false;
 
diff --git a/winsup/cygwin/path.cc b/winsup/cygwin/path.cc
index b758bc50ea..f6bfe08359 100644
--- a/winsup/cygwin/path.cc
+++ b/winsup/cygwin/path.cc
@@ -1722,6 +1722,173 @@ conv_path_list (const char *src, char *dst, size_t size,
 
 /********************** Symbolic Link Support **************************/
 
+static int
+recursiveCopyCheckSymlink(PUNICODE_STRING src, bool& isdirlink)
+{
+  path_conv pc (src, PC_SYM_NOFOLLOW|PC_SYM_NOFOLLOW_REP);
+  if (pc.error)
+    {
+      set_errno (pc.error);
+      return -1;
+    }
+  isdirlink = pc.issymlink ();
+  return 0;
+}
+
+/*
+  Create a deep copy of src as dst, while avoiding descending in origpath.
+*/
+static int
+recursiveCopy (PUNICODE_STRING src, PUNICODE_STRING dst, USHORT origsrclen,
+	       USHORT origdstlen, PWIN32_FIND_DATAW dHfile = NULL)
+{
+  HANDLE dH = INVALID_HANDLE_VALUE;
+  NTSTATUS status;
+  int srcpos = src->Length;
+  int dstpos = dst->Length;
+  int res = -1;
+  bool freedHfile = false;
+
+  if (!dHfile)
+    {
+      dHfile = (PWIN32_FIND_DATAW) cmalloc_abort (HEAP_STR, sizeof (*dHfile));
+      freedHfile = true;
+    }
+
+  debug_printf ("recursiveCopy (%S, %S)", src, dst);
+
+  /* Create the destination directory */
+  if (!CreateDirectoryExW (src->Buffer, dst->Buffer, NULL))
+    {
+      debug_printf ("CreateDirectoryExW(%S, %S, 0) failed", src, dst);
+      __seterrno ();
+      goto done;
+    }
+  /* Descend into the source directory */
+  if (src->Buffer[(src->Length - 1) / sizeof (WCHAR)] != L'\\')
+    {
+      status = RtlAppendUnicodeToString (src, L"\\*");
+    }
+  else
+    {
+      status = RtlAppendUnicodeToString (src, L"*");
+      srcpos -= sizeof (WCHAR);
+    }
+  if (!NT_SUCCESS (status))
+    {
+      __seterrno_from_nt_status (status);
+      goto done;
+    }
+  if (dst->Buffer[(dst->Length - 1) / sizeof (WCHAR)] != L'\\')
+      status = RtlAppendUnicodeToString (dst, L"\\");
+  else
+      dstpos -= sizeof (WCHAR);
+  if (!NT_SUCCESS (status))
+    {
+      __seterrno_from_nt_status (status);
+      goto done;
+    }
+
+  dH = FindFirstFileExW (src->Buffer, FindExInfoBasic, dHfile,
+			 FindExSearchNameMatch, NULL,
+			 FIND_FIRST_EX_LARGE_FETCH);
+  if (dH == INVALID_HANDLE_VALUE)
+    {
+      __seterrno ();
+      goto done;
+    }
+
+  do
+    {
+      bool isdirlink = false;
+      debug_printf ("dHfile: %W", dHfile->cFileName);
+      if (dHfile->cFileName[0] == L'.' &&
+	  (!dHfile->cFileName[1] ||
+	   (dHfile->cFileName[1] == L'.' && !dHfile->cFileName[2])))
+	continue;
+      /* Append the directory item filename to both source and destination */
+      src->Length = srcpos + sizeof (WCHAR);
+      dst->Length = dstpos + sizeof (WCHAR);
+      status = RtlAppendUnicodeToString (src, dHfile->cFileName);
+      if (!NT_SUCCESS (status))
+	{
+	  __seterrno_from_nt_status (status);
+	  goto done;
+	}
+      status = RtlAppendUnicodeToString (dst, dHfile->cFileName);
+      if (!NT_SUCCESS (status))
+	{
+	  __seterrno_from_nt_status (status);
+	  goto done;
+	}
+      debug_printf ("%S -> %S", src, dst);
+      if ((dHfile->dwFileAttributes &
+	    (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_REPARSE_POINT)) ==
+	  (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_REPARSE_POINT))
+	{
+	  /* I was really hoping to avoid using path_conv in the recursion,
+	     but maybe putting it in its own function will prevent it from
+	     taking up space in the stack frame */
+	  if (recursiveCopyCheckSymlink (src, isdirlink))
+	    goto done;
+	}
+      if (isdirlink)
+        {
+	  /* CreateDirectoryEx seems to "copy" directory reparse points, which
+	     CopyFileEx can only do with a flag introduced in 19041. */
+	  if (!CreateDirectoryExW (src->Buffer, dst->Buffer, NULL))
+	    {
+	      debug_printf ("CreateDirectoryExW(%S, %S, 0) failed", src, dst);
+	      __seterrno ();
+	      goto done;
+	    }
+	}
+      else if (dHfile->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+	{
+	  /* Recurse into the child directory */
+	  /* avoids endless recursion */
+	  if (src->Length <= origsrclen ||
+	      (!wcsncmp (src->Buffer, dst->Buffer, origdstlen / sizeof (WCHAR)) &&
+	       (!src->Buffer[origdstlen / sizeof (WCHAR)] ||
+		iswdirsep(src->Buffer[origdstlen / sizeof (WCHAR)]))))
+	    {
+	      set_errno (ELOOP);
+	      goto done;
+	    }
+	  if (recursiveCopy (src, dst, origsrclen, origdstlen, dHfile))
+	    goto done;
+	}
+      else
+	{
+	  /* Just copy the file */
+	  if (!CopyFileExW (src->Buffer, dst->Buffer, NULL, NULL, NULL,
+			    COPY_FILE_COPY_SYMLINK))
+	    {
+	      __seterrno ();
+	      goto done;
+	    }
+	}
+    }
+  while (FindNextFileW (dH, dHfile));
+
+  if (GetLastError() != ERROR_NO_MORE_FILES)
+    {
+      __seterrno ();
+      goto done;
+    }
+  res = 0;
+
+done:
+
+  if (dH != INVALID_HANDLE_VALUE)
+    FindClose (dH);
+
+  if (freedHfile)
+    cfree (dHfile);
+
+  return res;
+}
+
 /* Create a symlink from FROMPATH to TOPATH. */
 
 extern "C" int
@@ -2048,6 +2215,84 @@ symlink_wsl (const char *oldpath, path_conv &win32_newpath)
   return 0;
 }
 
+int
+symlink_deepcopy (const char *oldpath, path_conv &win32_newpath)
+{
+  tmp_pathbuf tp;
+  path_conv win32_oldpath;
+
+  resolve_symlink_target (oldpath, win32_newpath, win32_oldpath);
+  if (win32_oldpath.error)
+    {
+      set_errno (win32_oldpath.error);
+      return -1;
+    }
+  if (win32_oldpath.isspecial ())
+    return -2;
+
+  /* MSYS copy file instead make symlink */
+  /* As a MSYS limitation, the source path must exist. */
+  if (!win32_oldpath.exists ())
+    {
+      set_errno (ENOENT);
+      return -1;
+    }
+
+  PUNICODE_STRING w_oldpath = win32_oldpath.get_nt_native_path ();
+  PUNICODE_STRING w_newpath = win32_newpath.get_nt_native_path ();
+  if (w_oldpath->Buffer[1] == L'?')
+    w_oldpath->Buffer[1] = L'\\';
+  if (w_newpath->Buffer[1] == L'?')
+    w_newpath->Buffer[1] = L'\\';
+  if (win32_oldpath.isdir ())
+    {
+      /* we need a larger UNICODE_STRING MaximumLength than
+	 get_nt_native_path allocates for the recursive copy */
+      UNICODE_STRING u_oldpath, u_newpath;
+      RtlCopyUnicodeString (tp.u_get (&u_oldpath), w_oldpath);
+      RtlCopyUnicodeString (tp.u_get (&u_newpath), w_newpath);
+      return recursiveCopy (&u_oldpath, &u_newpath,
+			    u_oldpath.Length, u_newpath.Length);
+    }
+  else
+    {
+      bool isdirlink = false;
+      if (win32_oldpath.issymlink () &&
+	  win32_oldpath.is_known_reparse_point ())
+	{
+	  /* Is there a better way to know this? */
+	  DWORD attr = getfileattr (win32_oldpath.get_win32 (),
+				    !!win32_oldpath.objcaseinsensitive ());
+	  if (attr == INVALID_FILE_ATTRIBUTES)
+	    {
+	      __seterrno ();
+	      return -1;
+	    }
+	  isdirlink = attr & FILE_ATTRIBUTE_DIRECTORY;
+	}
+      if (isdirlink)
+        {
+	  /* CreateDirectoryEx seems to "copy" directory reparse points, which
+	     CopyFileEx can only do with a flag introduced in 19041. */
+	  if (!CreateDirectoryExW (w_oldpath->Buffer, w_newpath->Buffer, NULL))
+	    {
+	      debug_printf ("CreateDirectoryExW(%S, %S, 0) failed", w_oldpath,
+			    w_newpath);
+	      __seterrno ();
+	      return -1;
+	    }
+	}
+      else if (!CopyFileExW (w_oldpath->Buffer, w_newpath->Buffer, NULL, NULL,
+			NULL, COPY_FILE_COPY_SYMLINK))
+	{
+	  __seterrno ();
+	  return -1;
+	}
+    }
+
+  return 0;
+}
+
 int
 symlink_worker (const char *oldpath, path_conv &win32_newpath, bool isdevice)
 {
@@ -2115,6 +2360,13 @@ symlink_worker (const char *oldpath, path_conv &win32_newpath, bool isdevice)
 	case WSYM_nfs:
 	  res = symlink_nfs (oldpath, win32_newpath);
 	  __leave;
+	case WSYM_deepcopy:
+	  res = symlink_deepcopy (oldpath, win32_newpath);
+	  if (!res || res == -1)
+	    __leave;
+	  /* fall back to sysfile symlink type */
+	  wsym_type = WSYM_sysfile;
+	  break;
 	case WSYM_native:
 	case WSYM_nativestrict:
 	  res = symlink_native (oldpath, win32_newpath);

From 162b87243c304b684b3e9d9bffdb988c0690aae4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B5=D0=B8=CC=86=20=D0=9F?=
 =?UTF-8?q?=D0=B0=D0=B2=D0=BB=D0=BE=D0=B2?= <alexey.pawlow@gmail.com>
Date: Sun, 14 Apr 2019 21:48:54 +0300
Subject: [PATCH 27/84] Automatically rewrite TERM=msys to TERM=cygwin

With MSys1, it was necessary to set the TERM variable to "msys". To
allow for a smooth transition from MSys1 to MSys2, let's simply handle
TERM=msys as if the user had not specified TERM at all and wanted us to
use our preferred TERM value.
---
 winsup/cygwin/environ.cc | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/winsup/cygwin/environ.cc b/winsup/cygwin/environ.cc
index 5fb3f53ef5..117531367e 100644
--- a/winsup/cygwin/environ.cc
+++ b/winsup/cygwin/environ.cc
@@ -908,7 +908,16 @@ win32env_to_cygenv (PWCHAR rawenv, bool posify)
       char *eq = strchrnul (newp, '=');
       ucenv (newp, eq);    /* uppercase env vars which need it */
       if (*newp == 'T' && strncmp (newp, "TERM=", 5) == 0)
-        sawTERM = 1;
+	    {
+	      /* backwards compatibility: override TERM=msys by TERM=cygwin */
+	      if (strcmp (newp + 5, "msys") == 0)
+		{
+		  free(newp);
+		  i--;
+		  continue;
+		}
+	      sawTERM = 1;
+	    }
 #ifdef __MSYS__
       else if (*newp == 'M' && strncmp (newp, "MSYS=", 5) == 0)
         parse_options (newp + 5);

From 317ab5c021d2072be8d3d47b7bee402da1e5d65e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B5=D0=B8=CC=86=20=D0=9F?=
 =?UTF-8?q?=D0=B0=D0=B2=D0=BB=D0=BE=D0=B2?= <alexey.pawlow@gmail.com>
Date: Sun, 14 Apr 2019 21:50:55 +0300
Subject: [PATCH 28/84] Do not convert environment for strace

Strace is a Windows program so MSYS2 will convert all arguments and environment vars and that makes debugging msys2 software with strace very tricky.
---
 winsup/cygwin/spawn.cc | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/winsup/cygwin/spawn.cc b/winsup/cygwin/spawn.cc
index 785586af6d..cc1cf49da6 100644
--- a/winsup/cygwin/spawn.cc
+++ b/winsup/cygwin/spawn.cc
@@ -539,11 +539,13 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
       bool switch_user = ::cygheap->user.issetuid ()
 			 && (::cygheap->user.saved_uid
 			     != ::cygheap->user.real_uid);
+      bool keep_posix = (iscmd (argv[0], "strace.exe")
+			|| iscmd (argv[0], "strace")) ? true : real_path.iscygexec ();
       moreinfo->envp = build_env (envp, envblock, moreinfo->envc,
 				  real_path.iscygexec (),
 				  switch_user ? ::cygheap->user.primary_token ()
 					      : NULL,
-				  real_path.iscygexec ());
+				  keep_posix);
       if (!moreinfo->envp || !envblock)
 	{
 	  set_errno (E2BIG);

From 635e83729ab3d854e9ee332137fd9e90eb9e2e35 Mon Sep 17 00:00:00 2001
From: Ray Donnelly <mingw.android@gmail.com>
Date: Sun, 23 Aug 2015 20:47:30 +0100
Subject: [PATCH 29/84] strace.cc: Don't set MSYS=noglob

Commit message for this code was:

* strace.cc (create_child): Set CYGWIN=noglob when starting new process so that

  Cygwin will leave already-parsed the command line alonw."

I can see no reason for it and it badly breaks the ability to use
strace.exe to investigate calling a Cygwin program from a Windows
program, for example:
strace mingw32-make.exe
.. where mingw32-make.exe finds sh.exe and uses it as the shell.
The reason it badly breaks this use-case is because dcrt0.cc depends
on globbing to happen to parse commandlines from Windows programs;
irrespective of whether they contain any glob patterns or not.

See quoted () comment:
"This must have been run from a Windows shell, so preserve
 quotes for globify to play with later."
---
 winsup/utils/mingw/strace.cc | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/winsup/utils/mingw/strace.cc b/winsup/utils/mingw/strace.cc
index 29db640239..25adf4e8dd 100644
--- a/winsup/utils/mingw/strace.cc
+++ b/winsup/utils/mingw/strace.cc
@@ -354,10 +354,28 @@ create_child (char **argv)
   make_command_line (one_line, argv);
 
   SetConsoleCtrlHandler (NULL, 0);
+/* Commit message for this code was:
+"* strace.cc (create_child): Set CYGWIN=noglob when starting new process so that
+
+  Cygwin will leave already-parsed the command line alonw."
+
+  I can see no reason for it and it badly breaks the ability to use
+  strace.exe to investigate calling a Cygwin program from a Windows
+  program, for example:
+  strace mingw32-make.exe
+  .. where mingw32-make.exe finds sh.exe and uses it as the shell.
+  The reason it badly breaks this use-case is because dcrt0.cc depends
+  on globbing to happen to parse commandlines from Windows programs;
+  irrespective of whether they contain any glob patterns or not.
+  
+  See quoted () comment:
+  "This must have been run from a Windows shell, so preserve
+     quotes for globify to play with later."
+
   const char *cygwin_env = getenv ("MSYS");
   const char *space;
 
-  if (cygwin_env && strlen (cygwin_env) <= 256) /* sanity check */
+  if (cygwin_env && strlen (cygwin_env) <= 256) // sanity check
     space = " ";
   else
     space = cygwin_env = "";
@@ -365,6 +383,7 @@ create_child (char **argv)
 				  + strlen (space) + strlen (cygwin_env));
   sprintf (newenv, "MSYS=noglob%s%s", space, cygwin_env);
   _putenv (newenv);
+*/
   ret = CreateProcess (0, one_line.buf,	/* command line */
 		       NULL,	/* Security */
 		       NULL,	/* thread */

From ec9b0f5fad49a2a725f9607c4e6a3d6f128a492e Mon Sep 17 00:00:00 2001
From: Ray Donnelly <mingw.android@gmail.com>
Date: Fri, 21 Aug 2015 09:52:47 +0100
Subject: [PATCH 30/84] Add debugging for strace make_command_line

---
 winsup/utils/mingw/strace.cc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/winsup/utils/mingw/strace.cc b/winsup/utils/mingw/strace.cc
index 25adf4e8dd..d346abc4e7 100644
--- a/winsup/utils/mingw/strace.cc
+++ b/winsup/utils/mingw/strace.cc
@@ -352,6 +352,7 @@ create_child (char **argv)
     flags |= CREATE_NEW_CONSOLE | CREATE_NEW_PROCESS_GROUP;
 
   make_command_line (one_line, argv);
+  printf ("create_child: %s\n", one_line.buf);
 
   SetConsoleCtrlHandler (NULL, 0);
 /* Commit message for this code was:

From aae2354437aa66cf26b72451be333f3105ee2aaf Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Wed, 17 May 2017 18:13:32 +0200
Subject: [PATCH 31/84] strace --quiet: be *really* quiet

The biggest problem with strace spitting out `create_child: ...` despite
being asked to be real quiet is that its output can very well interfere
with scripts' operations.

For example, when running any of Git for Windows' shell scripts with
`GIT_STRACE_COMMANDS=/path/to/logfile` (which is sadly an often needed
debugging technique while trying to address the many MSYS2 issues Git for
Windows faces), any time the output of any command is redirected into a
variable, it will include that `create_child: ...` line, wreaking havoc
with Git's expectations.

So let's just really be quiet when we're asked to be quiet.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/utils/mingw/strace.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/winsup/utils/mingw/strace.cc b/winsup/utils/mingw/strace.cc
index d346abc4e7..a6b2e5d548 100644
--- a/winsup/utils/mingw/strace.cc
+++ b/winsup/utils/mingw/strace.cc
@@ -352,7 +352,8 @@ create_child (char **argv)
     flags |= CREATE_NEW_CONSOLE | CREATE_NEW_PROCESS_GROUP;
 
   make_command_line (one_line, argv);
-  printf ("create_child: %s\n", one_line.buf);
+  if (!quiet)
+    printf ("create_child: %s\n", one_line.buf);
 
   SetConsoleCtrlHandler (NULL, 0);
 /* Commit message for this code was:

From 9928501f241ff534ba0df6b1397d8ad74f29fba9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B5=D0=B8=CC=86=20=D0=9F?=
 =?UTF-8?q?=D0=B0=D0=B2=D0=BB=D0=BE=D0=B2?= <alexey.pawlow@gmail.com>
Date: Sun, 14 Apr 2019 22:13:51 +0300
Subject: [PATCH 32/84] path_conv: special-case root directory to have trailing
 slash

When converting `/c/` to `C:\`, the trailing slash is actually really
necessary, as `C:` is not an absolute path.

We must be very careful to do this only for root directories, though. If
we kept the trailing slash also for, say, `/y/directory/`, we would run
into the following issue: On FAT file systems, the normalized path is
used to fake inode numbers. As a result, `Y:\directory\` and
`Y:\directory` have different inode numbers!!!

This would result in very non-obvious symptoms. Back when we were too
careless about keeping the trailing slash, it was reported to the Git
for Windows project that the `find` and `rm` commands can error out on
FAT file systems with very confusing "No such file or directory" errors,
for no good reason.

During the original investigation, Vasil Minkov pointed out in
https://github.com/git-for-windows/git/issues/1497#issuecomment-372665870,
that this bug had been fixed in Cygwin as early as 1997... and the bug
was unfortunately reintroduced into early MSYS2 versions.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/path.cc | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/winsup/cygwin/path.cc b/winsup/cygwin/path.cc
index f6bfe08359..5ce0ba0360 100644
--- a/winsup/cygwin/path.cc
+++ b/winsup/cygwin/path.cc
@@ -742,6 +742,12 @@ path_conv::check (const char *src, unsigned opt,
 	      need_directory = 1;
 	      *--tail = '\0';
 	    }
+	  /* Special case for "/" must set need_directory, without removing
+	     trailing slash */
+	  else if (tail == path_copy + 1 && isslash (tail[-1]))
+	    {
+	      need_directory = 1;
+	    }
 	  path_end = tail;
 
 	  /* Scan path_copy from right to left looking either for a symlink
@@ -1288,6 +1294,7 @@ path_conv::check (const char *src, unsigned opt,
 		cfree (wide_path);
 	      wide_path = NULL;
 	    }
+
 	  if (need_directory)
 	    {
 	      size_t n = strlen (this->path);

From 15b900547389ea8c6dd6423cdcc996a4142a626c Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Tue, 8 Nov 2022 16:24:20 +0100
Subject: [PATCH 33/84] When converting to a Unix path, avoid double trailing
 slashes

When calling `cygpath -u C:/msys64/` in an MSYS2 setup that was
installed into `C:/msys64/`, the result should be `/`, not `//`.

Let's ensure that we do not append another trailing slash if the
converted path already ends in a slash.

This fixes https://github.com/msys2/msys2-runtime/issues/112

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/mount.cc | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/winsup/cygwin/mount.cc b/winsup/cygwin/mount.cc
index affb7e9266..ff0279336b 100644
--- a/winsup/cygwin/mount.cc
+++ b/winsup/cygwin/mount.cc
@@ -1018,6 +1018,9 @@ mount_info::conv_to_posix_path (const char *src_path, char *posix_path,
 	nextchar = 1;
 
       int addslash = nextchar > 0 ? 1 : 0;
+      /* avoid appending a slash if the result already has a trailing slash */
+      if (append_slash && mi.posix_pathlen && mi.posix_path[mi.posix_pathlen-1] == '/')
+	append_slash = addslash = 0;
       if ((mi.posix_pathlen + (pathbuflen - mi.native_pathlen) + addslash) >= NT_MAX_PATH)
 	return ENAMETOOLONG;
       strcpy (posix_path, mi.posix_path);

From 570a0124015d67fb9870f41c75cf76fb4a3e5e2b Mon Sep 17 00:00:00 2001
From: Christoph Reiter <reiter.christoph@gmail.com>
Date: Sun, 20 Nov 2022 13:57:36 +0100
Subject: [PATCH 34/84] msys2_path_conv: pass PC_NOFULL to path_conv

In theory this doesn't make a difference because posix_to_win32_path()
is only called with rooted/absolute paths, but as pointed out in
https://github.com/msys2/msys2-runtime/pull/103 PC_NOFULL will preserve
the trailing slash of unix paths (for some reason).

See "cygpath -m /bin/" (preserved) vs "cygpath -am /bin/" (dropped)

One use case where we need to trailing slashes to be preserved is the GCC build
system:
https://github.com/gcc-mirror/gcc/blob/6d82e0fea5f988e829912a/gcc/Makefile.in#L2314

The Makefile appends a slash to the prefixes and the C code doing relocation will
treat the path as a directory if there is a trailing slash. See
https://github.com/msys2/MINGW-packages/issues/14173 for details.

With this change all our MSYS2 path_conv tests pass again.
---
 winsup/cygwin/msys2_path_conv.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/winsup/cygwin/msys2_path_conv.cc b/winsup/cygwin/msys2_path_conv.cc
index c52728759e..d584800c00 100644
--- a/winsup/cygwin/msys2_path_conv.cc
+++ b/winsup/cygwin/msys2_path_conv.cc
@@ -682,7 +682,7 @@ void posix_to_win32_path(const char* from, const char* to, char** dst, const cha
         strncpy(one_path, from, to-from);
         one_path[to-from] = '\0';
 
-        path_conv conv (one_path, 0);
+        path_conv conv (one_path, PC_NOFULL);
         if (conv.error)
         {
           set_errno(conv.error);

From de30986ba8c300481b8afa4a22af868a38998f66 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EB=A7=88=EB=88=84=EC=97=98?= <nalla@hamal.uberspace.de>
Date: Wed, 17 Jun 2015 09:30:41 +0200
Subject: [PATCH 35/84] path-conversion: Introduce ability to switch off
 conversion.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When calling windows native apps from MSYS2, the runtime tries to
convert commandline arguments by a specific set of rules. This idea was
inherited from the MSys/MinGW project (which is now seemingly stale, yet
must be credited with championing this useful feature, see MinGW wiki
https://web.archive.org/web/20201112005258/http://www.mingw.org/wiki/Posix_path_conversion).

If the user does not want that behavior on a big scale, e.g. inside a
Bash script, with the changes introduced in this commit, the user can
now set the the environment variable `MSYS_NO_PATHCONV` when calling
native windows commands.

This is a feature that has been introduced in Git for Windows via
https://github.com/git-for-windows/msys2-runtime/pull/11 and it predates
support for the `MSYS2_ENV_CONV_EXCL` and `MSYS2_ARG_CONV_EXCL`
environment variables in the MSYS2 runtime; Many users find the
simplicity of `MSYS_NO_PATHCONV` appealing.

So let's teach MSYS2 proper this simple trick that still allows using
the sophisticated `MSYS2_*_CONV_EXCL` facilities but also offers a
convenient catch-all "just don't convert anything" knob.

Signed-off-by: 마누엘 <nalla@hamal.uberspace.de>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/msys2_path_conv.cc | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/winsup/cygwin/msys2_path_conv.cc b/winsup/cygwin/msys2_path_conv.cc
index d584800c00..4c0cc82cf2 100644
--- a/winsup/cygwin/msys2_path_conv.cc
+++ b/winsup/cygwin/msys2_path_conv.cc
@@ -341,6 +341,16 @@ path_type find_path_start_and_type(const char** src, int recurse, const char* en
 
     if (*it == '\0' || it == end) return NONE;
 
+    /*
+     * Skip path mangling when environment indicates it.
+     */
+    const char *no_pathconv = getenv ("MSYS_NO_PATHCONV");
+
+    if (no_pathconv) {
+        *src = end;
+        return NONE;
+    }
+
     /* Let's not convert ~/.file to ~C:\msys64\.file */
     if (*it == '~') {
 skip_p2w:

From a1ad8856c16c8eacae039852ba278afbf3713234 Mon Sep 17 00:00:00 2001
From: Ray Donnelly <mingw.android@gmail.com>
Date: Fri, 21 Aug 2015 12:52:09 +0100
Subject: [PATCH 36/84] dcrt0.cc: Untangle allow_glob from winshell

Otherwise if globbing is allowed and we get called from a
Windows program, build_argv thinks we've been called from
a Cygwin program.
---
 winsup/cygwin/dcrt0.cc | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/winsup/cygwin/dcrt0.cc b/winsup/cygwin/dcrt0.cc
index e19b7d3904..8fc3672d2d 100644
--- a/winsup/cygwin/dcrt0.cc
+++ b/winsup/cygwin/dcrt0.cc
@@ -154,12 +154,12 @@ isquote (char c)
 
 /* Step over a run of characters delimited by quotes */
 static /*__inline*/ char *
-quoted (char *cmd, int winshell)
+quoted (char *cmd, int winshell, int glob)
 {
   char *p;
   char quote = *cmd;
 
-  if (!winshell)
+  if (!winshell || !glob)
     {
       char *p;
       strcpy (cmd, cmd + 1);
@@ -169,8 +169,8 @@ quoted (char *cmd, int winshell)
     }
 
   const char *s = quote == '\'' ? "'" : "\\\"";
-  /* This must have been run from a Windows shell, so preserve
-     quotes for globify to play with later. */
+  /* This must have been run from a Windows shell and globbing is enabled,
+     so preserve quotes for globify to play with later. */
   while (*cmd && *++cmd)
     if ((p = strpbrk (cmd, s)) == NULL)
       {
@@ -292,7 +292,7 @@ globify (char *word, char **&argv, int &argc, int &argvlen)
 /* Build argv, argc from string passed from Windows.  */
 
 static void
-build_argv (char *cmd, char **&argv, int &argc, int winshell)
+build_argv (char *cmd, char **&argv, int &argc, int winshell, int glob)
 {
   int argvlen = 0;
   int nesting = 0;		// monitor "nesting" from insert_file
@@ -326,7 +326,7 @@ build_argv (char *cmd, char **&argv, int &argc, int winshell)
 		 a Cygwin process, or if the word starts with a '@'.
 		 In this case, the insert_file function needs an unquoted
 		 DOS filename and globbing isn't performed anyway. */
-	      cmd = quoted (cmd, winshell && argc > 0 && *word != '@');
+	      cmd = quoted (cmd, winshell && argc > 0 && *word != '@', glob);
 	    }
 	  if (issep (*cmd))	// End of argument if space
 	    break;
@@ -352,7 +352,7 @@ build_argv (char *cmd, char **&argv, int &argc, int winshell)
 	}
 
       /* Add word to argv file after (optional) wildcard expansion. */
-      if (!winshell || !argc || !globify (word, argv, argc, argvlen))
+      if (!glob || !argc || !globify (word, argv, argc, argvlen))
 	{
 	  debug_printf ("argv[%d] = '%s'", argc, word);
 	  argv[argc++] = word;
@@ -907,6 +907,7 @@ dll_crt0_1 (void *)
       /* Scan the command line and build argv.  Expand wildcards if not
 	 called from another cygwin process. */
       build_argv (line, __argv, __argc,
+		  NOTSTATE (myself, PID_CYGPARENT),
 		  NOTSTATE (myself, PID_CYGPARENT) && allow_glob);
 
       /* Convert argv[0] to posix rules if it's currently blatantly

From a863a979c5c9e6075d087e5bd66f931a08953ccf Mon Sep 17 00:00:00 2001
From: Ray Donnelly <mingw.android@gmail.com>
Date: Mon, 24 Aug 2015 00:48:06 +0100
Subject: [PATCH 37/84] dcrt0.cc (globify): Don't quote literal strings
 differently when dos_spec

Reverts 25ba8f306f3099caf8397859019e936b90510e8d. I can't figure out what
the intention was. I'm sure I'll find out soon enough when everything breaks.

This change means that input of:
  '"C:/test.exe SOME_VAR=\"literal quotes\""'

becomes:
  'C:/test.exe SOME_VAR="literal quotes"'

instead of:
  'C:/test.exe SOME_VAR=\literal quotes\'

.. which is at least consistent with the result for:
  '"no_drive_or_colon SOME_VAR=\"literal quotes\""'

The old result of course resulted in the quoted string being split into
two arguments at the space which is clearly not intended.

I *guess* backslashes in dos paths may have been the issue here?
If so I don't care since we should not use them, ever, esp. not at
the expense of sensible forward-slash-containing input.
---
 winsup/cygwin/dcrt0.cc | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/winsup/cygwin/dcrt0.cc b/winsup/cygwin/dcrt0.cc
index 8fc3672d2d..3a2d0ec651 100644
--- a/winsup/cygwin/dcrt0.cc
+++ b/winsup/cygwin/dcrt0.cc
@@ -237,10 +237,20 @@ globify (char *word, char **&argv, int &argc, int &argvlen)
 	while (*++s && *s != quote)
 	  {
 	    mbstate_t mbs = { 0 };
+	    /* This used to be:
 	    if (dos_spec || *s != '\\')
-	      /* nothing */;
+	      // nothing
 	    else if (s[1] == quote || s[1] == '\\')
 	      s++;
+	    With commit message:
+	       dcrt0.cc (globify): Don't use \ quoting when apparently quoting a DOS path
+	       spec, even within a quoted string.
+	    But that breaks the "literal quotes" part of '"C:/test.exe SOME_VAR=\"literal quotes\""'
+	    giving:    'C:/test.exe SOME_VAR=\literal quotes\' (with \'s between each character)
+	    instead of 'C:/test.exe SOME_VAR="literal quotes"' (with \'s between each character)
+	    */
+	    if (*s == '\\' && (s[1] == quote || s[1] == '\\'))
+	      s++;
 	    *p++ = '\\';
 	    size_t cnt = isascii (*s) ? 1 : mbrtowi (NULL, s, MB_CUR_MAX, &mbs);
 	    if (cnt <= 1 || cnt == (size_t)-1)

From cf6b4fb98e29589b624ba24c1438fa6e447adeed Mon Sep 17 00:00:00 2001
From: Ray Donnelly <mingw.android@gmail.com>
Date: Fri, 21 Aug 2015 12:18:52 +0100
Subject: [PATCH 38/84] Add debugging for build_argv

---
 winsup/cygwin/dcrt0.cc | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/winsup/cygwin/dcrt0.cc b/winsup/cygwin/dcrt0.cc
index 3a2d0ec651..4d622cdc28 100644
--- a/winsup/cygwin/dcrt0.cc
+++ b/winsup/cygwin/dcrt0.cc
@@ -311,6 +311,8 @@ build_argv (char *cmd, char **&argv, int &argc, int winshell, int glob)
   argvlen = 0;
   argv = NULL;
 
+  debug_printf ("cmd = '%s', winshell = %d, glob = %d", cmd, winshell, glob);
+
   /* Scan command line until there is nothing left. */
   while (*cmd)
     {

From 240fcf26149323ff87e04cad202b78a2ba4f4770 Mon Sep 17 00:00:00 2001
From: Ray Donnelly <mingw.android@gmail.com>
Date: Sun, 10 Apr 2016 21:47:41 +0100
Subject: [PATCH 39/84] environ.cc: New facility/environment variable
 MSYS2_ENV_CONV_EXCL

Works very much like MSYS2_ARG_CONV_EXCL. In fact it uses the same
function, arg_heuristic_with_exclusions (). Also refactors parsing
the env. variables to use new function, string_split_delimited ().

The env. that is searched through is the merged (POSIX + Windows)
one. It remains to be seen if this should be made an option or not.

This feature was prompted because the R language (Windows exe) calls
bash to run configure.win, which then calls back into R to read its
config variables (LOCAL_SOFT) and when this happens, msys2-runtime
converts R_ARCH from "/x64" to an absolute Windows path and appends
it to another absolute path, R_HOME, forming an invalid path.
---
 winsup/cygwin/environ.cc                 | 34 +++++++++++++++++-------
 winsup/cygwin/local_includes/miscfuncs.h |  2 ++
 winsup/cygwin/miscfuncs.cc               | 20 ++++++++++++++
 winsup/cygwin/path.cc                    |  1 -
 winsup/cygwin/spawn.cc                   | 12 ++-------
 5 files changed, 48 insertions(+), 21 deletions(-)

diff --git a/winsup/cygwin/environ.cc b/winsup/cygwin/environ.cc
index 117531367e..a9cce9645a 100644
--- a/winsup/cygwin/environ.cc
+++ b/winsup/cygwin/environ.cc
@@ -1173,6 +1173,10 @@ build_env (const char * const *envp, PWCHAR &envblock, int &envc,
 
   int tl = 0;
   char **pass_dstp;
+#ifdef __MSYS__
+  char *msys2_env_conv_excl_env = NULL;
+  size_t msys2_env_conv_excl_count = 0;
+#endif
   char **pass_env = (char **) alloca (sizeof (char *)
 				      * (n + winnum + SPENVS_SIZE + 1));
   /* Iterate over input list, generating a new environment list and refreshing
@@ -1181,16 +1185,25 @@ build_env (const char * const *envp, PWCHAR &envblock, int &envc,
     {
       bool calc_tl = !no_envblock;
 #ifdef __MSYS__
-      /* Don't pass timezone environment to non-msys applications */
-      if (!keep_posix && ascii_strncasematch(*srcp, "TZ=", 3))
+      if (!keep_posix)
         {
-          const char *v = *srcp + 3;
-          if (*v == ':')
-            goto next1;
-          for (; *v; v++)
-            if (!isalpha(*v) && !isdigit(*v) &&
-                *v != '-' && *v != '+' && *v != ':')
-              goto next1;
+          /* Don't pass timezone environment to non-msys applications */
+          if (ascii_strncasematch(*srcp, "TZ=", 3))
+            {
+              const char *v = *srcp + 3;
+              if (*v == ':')
+                goto next1;
+              for (; *v; v++)
+                if (!isalpha(*v) && !isdigit(*v) &&
+                    *v != '-' && *v != '+' && *v != ':')
+                  goto next1;
+            }
+          else if (ascii_strncasematch(*srcp, "MSYS2_ENV_CONV_EXCL=", 20))
+            {
+              msys2_env_conv_excl_env = (char*)alloca (strlen(&(*srcp)[20])+1);
+              strcpy (msys2_env_conv_excl_env, &(*srcp)[20]);
+              msys2_env_conv_excl_count = string_split_delimited (msys2_env_conv_excl_env, ';');
+            }
         }
 #endif
       /* Look for entries that require special attention */
@@ -1315,7 +1328,8 @@ build_env (const char * const *envp, PWCHAR &envblock, int &envc,
 	    }
 #ifdef __MSYS__
 	  else if (!keep_posix) {
-	    char *win_arg = arg_heuristic(*srcp);
+	    char *win_arg = arg_heuristic_with_exclusions
+		   (*srcp, msys2_env_conv_excl_env, msys2_env_conv_excl_count);
 	    debug_printf("WIN32_PATH is %s", win_arg);
 	    p = cstrdup1(win_arg);
 	    if (win_arg != *srcp)
diff --git a/winsup/cygwin/local_includes/miscfuncs.h b/winsup/cygwin/local_includes/miscfuncs.h
index fd10e40f13..1f2627fb2d 100644
--- a/winsup/cygwin/local_includes/miscfuncs.h
+++ b/winsup/cygwin/local_includes/miscfuncs.h
@@ -84,6 +84,8 @@ void backslashify (const char *, char *, bool);
 void slashify (const char *, char *, bool);
 #define isslash(c) ((c) == '/')
 
+size_t string_split_delimited (char * string, char delimiter);
+
 extern void transform_chars (PWCHAR, PWCHAR);
 extern inline void
 transform_chars (PUNICODE_STRING upath, USHORT start_idx)
diff --git a/winsup/cygwin/miscfuncs.cc b/winsup/cygwin/miscfuncs.cc
index 31080d043a..f3bfba0e44 100644
--- a/winsup/cygwin/miscfuncs.cc
+++ b/winsup/cygwin/miscfuncs.cc
@@ -424,6 +424,26 @@ NT_readline::gets ()
     }
 }
 
+/* Searches through string for delimiter replacing each instance with '\0'
+   and returning the number of such delimited substrings. This function
+   Will return 0 for the NULL string and at least 1 otherwise. */
+
+size_t
+string_split_delimited (char * string, char delimiter)
+{
+  if ( string == NULL )
+      return 0;
+  size_t count = 1;
+  string = strchr ( string, delimiter );
+  while (string)
+    {
+      *string = '\0';
+      ++count;
+      string = strchr ( string + 1, delimiter );
+    }
+  return count;
+}
+
 /* Signal the thread name to any attached debugger
 
    (See "How to: Set a Thread Name in Native Code"
diff --git a/winsup/cygwin/path.cc b/winsup/cygwin/path.cc
index 5ce0ba0360..b3426093db 100644
--- a/winsup/cygwin/path.cc
+++ b/winsup/cygwin/path.cc
@@ -4177,7 +4177,6 @@ arg_heuristic_with_exclusions (char const * const arg, char const * exclusions,
     return arg_result;
   }
 
-  debug_printf("Input value: (%s)", arg);
   for (size_t excl = 0; excl < exclusions_count; ++excl)
     {
       /* Since we've got regex linked we should maybe switch to that, but
diff --git a/winsup/cygwin/spawn.cc b/winsup/cygwin/spawn.cc
index cc1cf49da6..2cc5716882 100644
--- a/winsup/cygwin/spawn.cc
+++ b/winsup/cygwin/spawn.cc
@@ -287,8 +287,7 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
   int res = -1;
 
   /* Environment variable MSYS2_ARG_CONV_EXCL contains a list
-     of ';' separated argument prefixes to pass un-modified..
-     It isn't applied to env. variables; only spawn arguments.
+     of ';' separated argument prefixes to pass un-modified.
      A value of * means don't convert any arguments. */
   char* msys2_arg_conv_excl_env = getenv("MSYS2_ARG_CONV_EXCL");
   char* msys2_arg_conv_excl = NULL;
@@ -297,14 +296,7 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
     {
       msys2_arg_conv_excl = (char*)alloca (strlen(msys2_arg_conv_excl_env)+1);
       strcpy (msys2_arg_conv_excl, msys2_arg_conv_excl_env);
-      msys2_arg_conv_excl_count = 1;
-      msys2_arg_conv_excl_env = strchr ( msys2_arg_conv_excl, ';' );
-      while (msys2_arg_conv_excl_env)
-        {
-          *msys2_arg_conv_excl_env = '\0';
-          ++msys2_arg_conv_excl_count;
-          msys2_arg_conv_excl_env = strchr ( msys2_arg_conv_excl_env + 1, ';' );
-        }
+      msys2_arg_conv_excl_count = string_split_delimited (msys2_arg_conv_excl, ';');
     }
 
   /* Check if we have been called from exec{lv}p or spawn{lv}p and mask

From 5581aba14fe9d3aa28952b10a96616b3c2c7e8a5 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Tue, 19 May 2020 13:49:37 +0200
Subject: [PATCH 40/84] Introduce the `enable_pcon` value for `MSYS`

It is simply the negation of `disable_pcon`, i.e. `MSYS=enable_pcon` is
equivalent to `MSYS=nodisable_pcon` (the former is slightly more
intuitive than the latter) and likewise `MSYS=noenable_pcon` is
equivalent to `MSYS=disable_pcon` (here, the latter is definitely more
intuitive than the former).

This is needed because we just demoted the pseudo console feature to be
opt-in instead of opt-out, and it would be awkward to recommend to users
to use "nodisable_pcon"... "nodisable" is not even a verb.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/environ.cc | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/winsup/cygwin/environ.cc b/winsup/cygwin/environ.cc
index a9cce9645a..b9600ef9a8 100644
--- a/winsup/cygwin/environ.cc
+++ b/winsup/cygwin/environ.cc
@@ -42,6 +42,7 @@ enum settings
     isfunc,
     setdword,
     setbool,
+    setnegbool,
     setbit
   };
 
@@ -118,6 +119,7 @@ static struct parse_thing
   } known[] NO_COPY =
 {
   {"disable_pcon", {&disable_pcon}, setbool, NULL, {{false}, {true}}},
+  {"enable_pcon", {&disable_pcon}, setnegbool, NULL, {{true}, {false}}},
   {"error_start", {func: error_start_init}, isfunc, NULL, {{0}, {0}}},
   {"export", {&export_settings}, setbool, NULL, {{false}, {true}}},
   {"glob", {func: glob_init}, isfunc, NULL, {{0}, {s: "normal"}}},
@@ -244,6 +246,13 @@ parse_options (const char *inbuf)
 		  *k->setting.b = !!strtol (eq, NULL, 0);
 		debug_printf ("%s%s", *k->setting.b ? "" : "no", k->name);
 		break;
+	      case setnegbool:
+		if (!istrue || !eq)
+		  *k->setting.b = k->values[istrue].i;
+		else
+		  *k->setting.b = !strtol (eq, NULL, 0);
+		debug_printf ("%s%s", !*k->setting.b ? "" : "no", k->name);
+		break;
 	      case setbit:
 		*k->setting.x &= ~k->values[istrue].i;
 		if (istrue || (eq && strtol (eq, NULL, 0)))

From b5154609113547a19e86e6a0c9e272f80937786a Mon Sep 17 00:00:00 2001
From: Christoph Reiter <reiter.christoph@gmail.com>
Date: Fri, 5 Jun 2020 20:09:11 +0200
Subject: [PATCH 41/84] popen: call /usr/bin/sh instead of /bin/sh

We mount /usr/bin to /bin, but in a chroot this is broken and we
have no /bin, so try to use the real path.

chroot is used by pacman to run install scripts when called with --root
and this broke programs in install scripts calling popen()
(install-info from texinfo for example)

There are more paths hardcoded to /bin in cygwin which might also be broken
in this scenario, so this maybe should be extended to all of them.
---
 winsup/cygwin/syscalls.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/winsup/cygwin/syscalls.cc b/winsup/cygwin/syscalls.cc
index eddc0f62fe..32959229b7 100644
--- a/winsup/cygwin/syscalls.cc
+++ b/winsup/cygwin/syscalls.cc
@@ -4536,7 +4536,7 @@ popen (const char *command, const char *in_type)
 
       /* Start a shell process to run the given command without forking. */
       child_info_spawn ch_spawn_local (_CH_NADA);
-      pid_t pid = ch_spawn_local.worker ("/bin/sh", argv, environ, _P_NOWAIT,
+      pid_t pid = ch_spawn_local.worker ("/usr/bin/sh", argv, environ, _P_NOWAIT,
 					 __std[0], __std[1]);
 
       /* Reinstate the close-on-exec state */

From b5a136901c01654a710d8fafdbd09ca4bf09d6f3 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Wed, 17 Mar 2021 17:41:02 +0100
Subject: [PATCH 42/84] Disable the 'cygwin' GitHub workflow

It does not work at all. For example, `rpm -E %fedora` says that there
should be version 33 of rpmsphere at
https://github.com/rpmsphere/noarch/tree/master/r, but there is only
version 32.

Another thing that is broken: Cygwin now assumes that a recent
mingw-w64-headers version is available, but Fedora apparently only
offers v7.0.0, which is definitely too old to accommodate for the
expectation of https://github.com/cygwin/cygwin/commit/c1f7c4d1b6d7.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 .github/workflows/cygwin.yml | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/.github/workflows/cygwin.yml b/.github/workflows/cygwin.yml
index 877f54cdeb..998dc01576 100644
--- a/.github/workflows/cygwin.yml
+++ b/.github/workflows/cygwin.yml
@@ -1,12 +1,6 @@
 name: cygwin
 
-on:
- push:
-   # since master is a symbolic reference to main, don't run for both
-   branches-ignore:
-     - 'master'
-   tags:
-     - '*'
+on: workflow_dispatch
 
 jobs:
   fedora-build:

From a69e75d4060cc6fdee8c45b5a9560932b31686f9 Mon Sep 17 00:00:00 2001
From: Christoph Reiter <reiter.christoph@gmail.com>
Date: Sun, 9 Aug 2020 14:02:51 +0200
Subject: [PATCH 43/84] CI: add a GHA for doing a basic build test

Build with --disable-dependency-tracking because we only build once
and this saves 3-4 minutes in CI.
---
 .github/workflows/build.yaml | 95 ++++++++++++++++++++++++++++++++++++
 1 file changed, 95 insertions(+)
 create mode 100644 .github/workflows/build.yaml

diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
new file mode 100644
index 0000000000..5eeac8e9b8
--- /dev/null
+++ b/.github/workflows/build.yaml
@@ -0,0 +1,95 @@
+name: build
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: windows-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: setup-msys2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: MSYS
+          update: true
+          install: msys2-devel base-devel autotools cocom diffutils gcc gettext-devel libiconv-devel make mingw-w64-cross-crt mingw-w64-cross-gcc mingw-w64-cross-zlib perl zlib-devel xmlto docbook-xsl
+
+      - name: Build
+        shell: msys2 {0}
+        run: |
+          (cd winsup && ./autogen.sh)
+          ./configure --disable-dependency-tracking --with-msys2-runtime-commit="$GITHUB_SHA"
+          make -j8
+
+      - name: Install
+        shell: msys2 {0}
+        run: |
+          make DESTDIR="$(pwd)"/_dest install
+
+      - name: Upload
+        uses: actions/upload-artifact@v4
+        with:
+          name: install
+          path: _dest/
+
+  generate-msys2-tests-matrix:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.matrix.outputs.matrix }}
+    steps:
+      - id: matrix
+        uses: msys2/msys2-tests/gha-matrix-gen@main
+
+  msys2-tests:
+    needs: [build, generate-msys2-tests-matrix]
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJson(needs.generate-msys2-tests-matrix.outputs.matrix) }}
+
+    name: msys2-tests ${{ matrix.msystem }}-${{ matrix.cc }}
+    runs-on: ${{ matrix.runner }}
+    env:
+      CC: ${{ matrix.cc }}
+      CXX: ${{ matrix.cxx }}
+      FC: ${{ matrix.fc }}
+    steps:
+      - id: msys2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: ${{ matrix.msystem }}
+          update: true
+          install: ${{ matrix.packages }}
+
+      - name: Add staging repo
+        shell: msys2 {0}
+        run: |
+          sed -i '1s|^|[staging]\nServer = https://repo.msys2.org/staging/\nSigLevel = Never\n|' /etc/pacman.conf
+
+      - name: Update using staging
+        shell: pwsh
+        run: |
+          msys2 -c 'pacman --noconfirm -Suuy'
+          $ErrorActionPreference = 'Stop'
+          $PSNativeCommandUseErrorActionPreference = $true
+          msys2 -c 'pacman --noconfirm -Suu'
+
+      - name: Download msys2-runtime artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: install
+          path: ${{ steps.msys2.outputs.msys2-location }}
+
+      - name: uname -a
+        shell: msys2 {0}
+        run: uname -a
+
+      - name: Run tests
+        uses: msys2/msys2-tests@main
+

From 422ef256c7ef51ec0eaf025b740a75f7c8ae7b05 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Fri, 22 Nov 2019 11:20:22 +0100
Subject: [PATCH 44/84] Set up a GitHub Action to keep in sync with Cygwin

This will help us by automating an otherwise tedious task.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 .github/workflows/sync-with-cygwin.yml | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 .github/workflows/sync-with-cygwin.yml

diff --git a/.github/workflows/sync-with-cygwin.yml b/.github/workflows/sync-with-cygwin.yml
new file mode 100644
index 0000000000..57bd30e5da
--- /dev/null
+++ b/.github/workflows/sync-with-cygwin.yml
@@ -0,0 +1,24 @@
+name: sync-with-cygwin
+
+# File: .github/workflows/repo-sync.yml
+
+on:
+  workflow_dispatch:
+  schedule:
+  - cron:  "42 * * * *"
+jobs:
+  repo-sync:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+    - name: Fetch Cygwin's latest master and tags
+      run: |
+        git init --bare
+        # Potentially use git://sourceware.org/git/newlib-cygwin.git directly, but GitHub seems more reliable
+        git fetch https://github.com/cygwin/cygwin master:refs/heads/cygwin/master 'refs/tags/*:refs/tags/*'
+    - name: Push to our fork
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      run: |
+        git push https://$GITHUB_ACTOR:$GITHUB_TOKEN@github.com/$GITHUB_REPOSITORY refs/heads/cygwin/master 'refs/tags/*:refs/tags/*'

From a3e87c109ba7fa90bb94b6b6e5a2abfc272b799c Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Wed, 12 Aug 2020 12:22:38 +0200
Subject: [PATCH 45/84] Expose full command-lines to other Win32 processes by
 default

In the Cygwin project, it was decided that the command-line of Cygwin
processes, as shown in the output of `wmic process list`, would suffer
from being truncated to 32k (and is transmitted to the child process via
a different mechanism, anyway), and therefore only the absolute path of
the executable is shown by default.

Users who would like to see the full command-line (even if it is
truncated) are expected to set `CYGWIN=wincmdln` (or, in MSYS2's case,
`MSYS=wincmdln`).

Seeing as MSYS2 tries to integrate much better with the surrounding
Win32 ecosystem than Cygwin, it makes sense to turn this on by default.

Users who wish to suppress it can still set `MSYS=nowincmdln`.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/globals.cc | 2 +-
 winsup/doc/cygwinenv.xml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/winsup/cygwin/globals.cc b/winsup/cygwin/globals.cc
index b7e0e21c52..79f9476330 100644
--- a/winsup/cygwin/globals.cc
+++ b/winsup/cygwin/globals.cc
@@ -70,7 +70,7 @@ bool allow_glob = true;
 bool ignore_case_with_glob;
 bool pipe_byte = true; /* Default to byte mode so that C# programs work. */
 bool reset_com;
-bool wincmdln;
+bool wincmdln = true;
 winsym_t allow_winsymlinks = WSYM_deepcopy;
 bool disable_pcon;
 bool winjitdebug = false;
diff --git a/winsup/doc/cygwinenv.xml b/winsup/doc/cygwinenv.xml
index fcb6e22485..4ea63b407a 100644
--- a/winsup/doc/cygwinenv.xml
+++ b/winsup/doc/cygwinenv.xml
@@ -90,7 +90,7 @@ time and when handles are inherited.  Defaults to set.</para>
 <listitem>
 <para><envar>(no)wincmdln</envar> - if set, the windows complete command
 line (truncated to ~32K) will be passed on any processes that it creates
-in addition to the normal UNIX argv list.  Defaults to not set.</para>
+in addition to the normal UNIX argv list.  Defaults to set.</para>
 </listitem>
 
 <listitem>

From ab684c659fa0f37f0d4134c371f69cb6b88ba1dd Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Mon, 16 Apr 2018 14:59:39 +0200
Subject: [PATCH 46/84] Add a helper to obtain a function's address in
 kernel32.dll

In particular, we are interested in the address of the CtrlRoutine
and the ExitProcess functions. Since kernel32.dll is loaded first thing,
the addresses will be the same for all processes (matching the
CPU architecture, of course).

This will help us with emulating SIGINT properly (by not sending signals
to *all* processes attached to the same Console, as
GenerateConsoleCtrlEvent() would do).

Co-authored-by: Naveen M K <naveen@syrusdark.website>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/configure.ac              |   5 +
 winsup/utils/mingw/Makefile.am   |  15 ++
 winsup/utils/mingw/getprocaddr.c | 310 +++++++++++++++++++++++++++++++
 3 files changed, 330 insertions(+)
 create mode 100644 winsup/utils/mingw/getprocaddr.c

diff --git a/winsup/configure.ac b/winsup/configure.ac
index 9b9b59dbcb..b9e3977fcf 100644
--- a/winsup/configure.ac
+++ b/winsup/configure.ac
@@ -106,6 +106,11 @@ if test "x$with_cross_bootstrap" != "xyes"; then
     test -n "$MINGW_CXX" || AC_MSG_ERROR([no acceptable MinGW g++ found in \$PATH])
     AC_CHECK_PROGS(MINGW_CC, ${target_cpu}-w64-mingw32-gcc)
     test -n "$MINGW_CC" || AC_MSG_ERROR([no acceptable MinGW gcc found in \$PATH])
+
+    AC_CHECK_PROGS(MINGW32_CC, i686-w64-mingw32-gcc)
+    test -n "$MINGW32_CC" || AC_MSG_ERROR([no acceptable mingw32 gcc found in \$PATH])
+    AC_CHECK_PROGS(MINGW64_CC, x86_64-w64-mingw32-gcc)
+    test -n "$MINGW64_CC" || AC_MSG_ERROR([no acceptable mingw64 gcc found in \$PATH])
 fi
 AM_CONDITIONAL(CROSS_BOOTSTRAP, [test "x$with_cross_bootstrap" != "xyes"])
 
diff --git a/winsup/utils/mingw/Makefile.am b/winsup/utils/mingw/Makefile.am
index 7f7317ae15..07b9f928d4 100644
--- a/winsup/utils/mingw/Makefile.am
+++ b/winsup/utils/mingw/Makefile.am
@@ -26,6 +26,21 @@ bin_PROGRAMS = \
 	ldh \
 	strace
 
+libexec_PROGRAMS = getprocaddr32 getprocaddr64
+
+# Must *not* use -O2 here, as it screws up the stack backtrace
+getprocaddr32.o: %32.o: %.c
+	$(MINGW32_CC) -c -o $@ $<
+
+getprocaddr32.exe: %.exe: %.o
+	$(MINGW32_CC) -o $@ $^ -static -ldbghelp
+
+getprocaddr64.o: %64.o: %.c
+	$(MINGW64_CC) -c -o $@ $<
+
+getprocaddr64.exe: %.exe: %.o
+	$(MINGW64_CC) -o $@ $^ -static -ldbghelp
+
 cygcheck_SOURCES = \
 	bloda.cc \
 	cygcheck.cc \
diff --git a/winsup/utils/mingw/getprocaddr.c b/winsup/utils/mingw/getprocaddr.c
new file mode 100644
index 0000000000..25814c7bdd
--- /dev/null
+++ b/winsup/utils/mingw/getprocaddr.c
@@ -0,0 +1,310 @@
+/* getprocaddr.c
+
+This program is a helper for getting the pointers for the
+functions in kernel32 module, and optionally injects a remote
+thread that runs those functions given a pid and exit code.
+
+We use dbghelp.dll to get the pointer to kernel32!CtrlRoutine
+because it isn't exported. For that, we try to generate console
+event (Ctrl+Break) ourselves, to find the pointer, and it is
+printed if asked to, or a remote thread is injected to run the
+given function.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+#include <stdio.h>
+#include <windows.h>
+
+/* Include dbghelp.h after windows.h */
+#include <dbghelp.h>
+
+static DWORD pid;
+static uintptr_t exit_code;
+static HANDLE CtrlEvent;
+
+static int
+inject_remote_thread_into_process (HANDLE process,
+                                   LPTHREAD_START_ROUTINE address,
+                                   uintptr_t exit_code,
+                                   DWORD *thread_return)
+{
+  int res = -1;
+
+  if (!address)
+    return res;
+  DWORD thread_id;
+  HANDLE thread = CreateRemoteThread (process, NULL, 1024 * 1024, address,
+                                      (PVOID)exit_code, 0, &thread_id);
+  if (thread)
+    {
+      /*
+       * Wait up to 10 seconds (arbitrary constant) for the thread to finish;
+       * Maybe we should wait forever? I have seen Cmd does so, but well...
+       */
+      if (WaitForSingleObject (thread, 10000) == WAIT_OBJECT_0)
+        res = 0;
+      /*
+      According to the docs at MSDN for GetExitCodeThread, it will
+      get the return value from the function, here CtrlRoutine. So, this
+      checks if the Ctrl Event is handled correctly by the process.
+
+      By some testing I could see CtrlRoutine returns 0 in case where
+      CtrlEvent set by SetConsoleCtrlHandler is handled correctly, in all
+      other cases it returns something non-zero(not sure what it that).
+      */
+      if (thread_return != NULL)
+        GetExitCodeThread (thread, thread_return);
+
+      CloseHandle (thread);
+    }
+
+  return res;
+}
+
+/* Here, we send a CtrlEvent to the current process for the
+ * sole purpose of capturing the address of the CtrlRoutine
+ * function, by looking the stack trace.
+ *
+ * This hack is needed because we cannot use GetProcAddress()
+ * as we do for ExitProcess(), because CtrlRoutine is not
+ * exported (although the .pdb files ensure that we can see
+ * it in a debugger).
+ */
+static WINAPI BOOL
+ctrl_handler (DWORD ctrl_type)
+{
+  unsigned short count;
+  void *address;
+  HANDLE process;
+  PSYMBOL_INFOW info;
+  DWORD64 displacement;
+  DWORD thread_return = 0;
+
+  count = CaptureStackBackTrace (1l /* skip this function */,
+                                 1l /* return only one trace item */, &address,
+                                 NULL);
+  if (count != 1)
+    {
+      fprintf (stderr, "Could not capture backtrace\n");
+      return FALSE;
+    }
+
+  process = GetCurrentProcess ();
+  if (!SymInitialize (process, NULL, TRUE))
+    {
+      fprintf (stderr, "Could not initialize symbols\n");
+      return FALSE;
+    }
+
+  info = (PSYMBOL_INFOW)malloc (sizeof (*info)
+                                + MAX_SYM_NAME * sizeof (wchar_t));
+  if (!info)
+    {
+      fprintf (stderr, "Could not allocate symbol info structure\n");
+      return FALSE;
+    }
+  info->SizeOfStruct = sizeof (*info);
+  info->MaxNameLen = MAX_SYM_NAME;
+
+  if (!SymFromAddrW (process, (DWORD64) (intptr_t)address, &displacement,
+                     info))
+    {
+      fprintf (stderr, "Could not get symbol info\n");
+      SymCleanup (process);
+      return FALSE;
+    }
+
+  if (pid == 0)
+    {
+      printf ("%p\n", (void *)(intptr_t)info->Address);
+    }
+  else
+    {
+      LPTHREAD_START_ROUTINE address =
+        (LPTHREAD_START_ROUTINE) (intptr_t)info->Address;
+      HANDLE h = OpenProcess (PROCESS_CREATE_THREAD |
+                              PROCESS_QUERY_INFORMATION |
+                              PROCESS_VM_OPERATION |
+                              PROCESS_VM_WRITE |
+                              PROCESS_VM_READ, FALSE, pid);
+      if (h == NULL)
+        {
+          fprintf (stderr, "OpenProcess failed: %ld\n", GetLastError ());
+          return 1;
+        }
+      /* Inject the remote thread only when asked to */
+      if (inject_remote_thread_into_process (h, address, exit_code,
+                                             &thread_return) < 0)
+        {
+          fprintf (stderr,
+                   "Error while injecting remote thread for pid(%lu)\n", pid);
+          exit (1); /*We should exit immediately or else there will a 10s hang
+                       waiting for the event to happen.*/
+        }
+      if (thread_return)
+        fprintf (stderr,
+                 "Injected remote thread for pid(%lu) returned %lu\n", pid,
+                 thread_return);
+    }
+  SymCleanup (process);
+  if (!SetEvent (CtrlEvent))
+    {
+      fprintf (stderr, "SetEvent failed (%ld)\n", GetLastError ());
+      return 1;
+    }
+  exit (thread_return != 0);
+}
+
+/* The easy route for finding the address of CtrlRoutine
+ * would be use GetProcAddress() but this isn't viable
+ * here because that symbol isn't exported.
+ */
+static int
+find_ctrl_routine_the_hard_way ()
+{
+  /*
+   * Avoid terminating all processes attached to the current console;
+   * This would happen if we used the same console as the caller, though,
+   * because we are sending a CtrlEvent on purpose (which _is_ sent to
+   * all processes connected to the same console, and the other processes
+   * are most likely unprepared for that CTRL_BREAK_EVENT and would be
+   * terminated as a consequence, _including the caller_).
+   *
+   * In case we get only one result from GetConsoleProcessList(), we don't
+   * need to create and allocate a new console, and it could avoid a console
+   * window popping up.
+   */
+  DWORD proc_lists;
+  if (GetConsoleProcessList (&proc_lists, 5) > 1)
+    {
+      if (!FreeConsole () && GetLastError () != ERROR_INVALID_PARAMETER)
+        {
+          fprintf (stderr, "Could not detach from current Console: %ld\n",
+                   GetLastError ());
+          return 1;
+        }
+      if (!AllocConsole ())
+        {
+          fprintf (stderr, "Could not allocate a new Console\n");
+          return 1;
+        }
+    }
+
+  CtrlEvent = CreateEvent (NULL,  // default security attributes
+                           TRUE,  // manual-reset event
+                           FALSE, // initial state is nonsignaled
+                           NULL   // object name
+  );
+
+  if (CtrlEvent == NULL)
+    {
+      fprintf (stderr, "CreateEvent failed (%ld)\n", GetLastError ());
+      return 1;
+    }
+
+
+  if (!SetConsoleCtrlHandler (ctrl_handler, TRUE))
+    {
+      fprintf (stderr, "Could not register Ctrl handler\n");
+      return 1;
+    }
+
+  if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, 0))
+    {
+      fprintf (stderr, "Could not simulate Ctrl+Break\n");
+      return 1;
+    }
+
+  if (WaitForSingleObject (CtrlEvent, 10000 /* 10 seconds*/) != WAIT_OBJECT_0)
+    {
+      fprintf (stderr, "WaitForSingleObject failed (%ld)\n", GetLastError ());
+      return 1;
+    }
+  return 0;
+}
+
+static void *
+get_proc_addr (const char * module_name, const char * function_name)
+{
+      HMODULE module = GetModuleHandle (module_name);
+      if (!module)
+        return NULL;
+      return (void *)GetProcAddress (module, function_name);
+}
+
+int
+main (int argc, char **argv)
+{
+  char *end;
+  void *address;
+  BOOL is_ctrl_routine;
+  DWORD thread_return = 0;
+
+  if (argc == 4)
+    {
+      exit_code = atoi (argv[2]);
+      pid = strtoul (argv[3], NULL, 0);
+    }
+  else if (argc == 2)
+    {
+      pid = 0;
+    }
+  else
+    {
+      fprintf (stderr, "Need a function name, exit code and pid\n"
+               "Or needs a function name.\n");
+      return 1;
+    }
+
+  is_ctrl_routine = strcmp (argv[1], "CtrlRoutine") == 0;
+  address = get_proc_addr ("kernel32", argv[1]);
+  if (is_ctrl_routine && !address)
+    {
+      /* CtrlRoutine is undocumented, and has been seen in both
+       * kernel32 and kernelbase
+       */
+      address = get_proc_addr ("kernelbase", argv[1]);
+      if (!address)
+        return find_ctrl_routine_the_hard_way ();
+    }
+
+  if (!address)
+    {
+      fprintf (stderr, "Could not get proc address\n");
+      return 1;
+    }
+
+  if (pid == 0)
+    {
+      printf ("%p\n", address);
+      fflush (stdout);
+      return 0;
+    }
+  HANDLE h = OpenProcess (PROCESS_CREATE_THREAD |
+                          PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION |
+                          PROCESS_VM_WRITE | PROCESS_VM_READ, FALSE, pid);
+  if (h == NULL)
+    {
+      fprintf (stderr, "OpenProcess failed: %ld\n", GetLastError ());
+      return 1;
+    }
+  /* Inject the remote thread */
+  if (inject_remote_thread_into_process (h, (LPTHREAD_START_ROUTINE)address,
+                                         exit_code, &thread_return) < 0)
+    {
+      fprintf (stderr, "Could not inject thread into process %lu\n", pid);
+      return 1;
+    }
+
+  if (is_ctrl_routine && thread_return)
+    {
+      fprintf (stderr,
+               "Injected remote thread for pid %lu returned %lu\n", pid,
+               thread_return);
+      return 1;
+    }
+
+  return 0;
+}

From 97045ebb056b6b6c5609b8d319872414008f6be5 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Fri, 20 Mar 2015 09:56:28 +0000
Subject: [PATCH 47/84] Emulate GenerateConsoleCtrlEvent() upon Ctrl+C

This patch is heavily inspired by the Git for Windows' strategy in
handling Ctrl+C.

When a process is terminated via TerminateProcess(), it has no chance to
do anything in the way of cleaning up. This is particularly noticeable
when a lengthy Git for Windows process tries to update Git's index file
and leaves behind an index.lock file. Git's idea is to remove the stale
index.lock file in that case, using the signal and atexit handlers
available in Linux. But those signal handlers never run.

Note: this is not an issue for MSYS2 processes because MSYS2 emulates
Unix' signal system accurately, both for the process sending the kill
signal and the process receiving it. Win32 processes do not have such a
signal handler, though, instead MSYS2 shuts them down via
`TerminateProcess()`.

For a while, Git for Windows tried to use a gentler method, described in
the Dr Dobb's article "A Safer Alternative to TerminateProcess()" by
Andrew Tucker (July 1, 1999),
http://www.drdobbs.com/a-safer-alternative-to-terminateprocess/184416547

Essentially, we injected a new thread into the running process that does
nothing else than running the ExitProcess() function.

However, this was still not in line with the way CMD handles Ctrl+C: it
gives processes a chance to do something upon Ctrl+C by calling
SetConsoleCtrlHandler(), and ExitProcess() simply never calls that
handler.

So for a while we tried to handle SIGINT/SIGTERM by attaching to the
console of the command to interrupt, and generating the very same event
as CMD does via GenerateConsoleCtrlEvent().

This method *still* was not correct, though, as it would interrupt
*every* process attached to that Console, not just the process (and its
children) that we wanted to signal. A symptom was that hitting Ctrl+C
while `git log` was shown in the pager would interrupt *the pager*.

The method we settled on is to emulate what GenerateConsoleCtrlEvent()
does, but on a process by process basis: inject a remote thread and call
the (private) function kernel32!CtrlRoutine.

To obtain said function's address, we use the dbghelp API to generate a
stack trace from a handler configured via SetConsoleCtrlHandler() and
triggered via GenerateConsoleCtrlEvent(). To avoid killing each and all
processes attached to the same Console as the MSYS2 runtime, we modify
the cygwin-console-helper to optionally print the address of
kernel32!CtrlRoutine to stdout, and then spawn it with a new Console.

Note that this also opens the door to handling 32-bit process from a
64-bit MSYS2 runtime and vice versa, by letting the MSYS2 runtime look
for the cygwin-console-helper.exe of the "other architecture" in a
specific place (we choose /usr/libexec/, as it seems to be the
convention for helper .exe files that are not intended for public
consumption).

The 32-bit helper implicitly links to libgcc_s_dw2.dll and
libwinpthread-1.dll, so to avoid cluttering /usr/libexec/, we look for
the helped of the "other" architecture in the corresponding mingw32/ or
mingw64/ subdirectory.

Among other bugs, this strategy to handle Ctrl+C fixes the MSYS2 side of
the bug where interrupting `git clone https://...` would send the
spawned-off `git remote-https` process into the background instead of
interrupting it, i.e. the clone would continue and its progress would be
reported mercilessly to the console window without the user being able
to do anything about it (short of firing up the task manager and killing
the appropriate task manually).

Note that this special-handling is only necessary when *MSYS2* handles
the Ctrl+C event, e.g. when interrupting a process started from within
MinTTY or any other non-cmd-based terminal emulator. If the process was
started from within `cmd.exe`'s terminal window, child processes are
already killed appropriately upon Ctrl+C, by `cmd.exe` itself.

Also, we can't trust the processes to end it's subprocesses upon receiving
Ctrl+C. For example, `pip.exe` from `python-pip` doesn't kill the python
it lauches (it tries to but fails), and I noticed that in cmd it kills python
also correctly, which mean we should kill all the process using
`exit_process_tree`.

Co-authored-by: Naveen M K <naveen@syrusdark.website>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/exceptions.cc                 |  24 +-
 winsup/cygwin/include/cygwin/exit_process.h | 364 ++++++++++++++++++++
 2 files changed, 384 insertions(+), 4 deletions(-)
 create mode 100644 winsup/cygwin/include/cygwin/exit_process.h

diff --git a/winsup/cygwin/exceptions.cc b/winsup/cygwin/exceptions.cc
index e724e37339..bdbf443c9b 100644
--- a/winsup/cygwin/exceptions.cc
+++ b/winsup/cygwin/exceptions.cc
@@ -29,6 +29,7 @@ details. */
 #include "exception.h"
 #include "posix_timer.h"
 #include "gcc_seh.h"
+#include "cygwin/exit_process.h"
 
 /* Define macros for CPU-agnostic register access.  The _CX_foo
    macros are for access into CONTEXT, the _MC_foo ones for access into
@@ -1654,10 +1655,25 @@ sigpacket::process ()
 dosig:
   if (have_execed)
     {
-      sigproc_printf ("terminating captive process");
-      if (::cygheap->ctty)
-	::cygheap->ctty->cleanup_before_exit ();
-      TerminateProcess (ch_spawn, sigExeced = si.si_signo);
+      switch (si.si_signo)
+        {
+        case SIGUSR1:
+        case SIGUSR2:
+        case SIGCONT:
+        case SIGSTOP:
+        case SIGTSTP:
+        case SIGTTIN:
+        case SIGTTOU:
+          system_printf ("Suppressing signal %d to win32 process (pid %u)",
+              (int)si.si_signo, (unsigned int)GetProcessId(ch_spawn));
+          goto done;
+        default:
+          sigproc_printf ("terminating captive process");
+          if (::cygheap->ctty)
+	    ::cygheap->ctty->cleanup_before_exit ();
+          rc = exit_process_tree (ch_spawn, 128 + (sigExeced = si.si_signo));
+          goto done;
+        }
     }
   /* Dispatch to the appropriate function. */
   sigproc_printf ("signal %d, signal handler %p", si.si_signo, handler);
diff --git a/winsup/cygwin/include/cygwin/exit_process.h b/winsup/cygwin/include/cygwin/exit_process.h
new file mode 100644
index 0000000000..0486a0c74a
--- /dev/null
+++ b/winsup/cygwin/include/cygwin/exit_process.h
@@ -0,0 +1,364 @@
+#ifndef EXIT_PROCESS_H
+#define EXIT_PROCESS_H
+
+/*
+ * This file contains functions to terminate a Win32 process, as gently as
+ * possible.
+ *
+ * If appropriate, we will attempt to emulate a console Ctrl event for the
+ * process. Otherwise we will fall back to terminating the process.
+ *
+ * As we do not want to export this function in the MSYS2 runtime, these
+ * functions are marked as file-local.
+ *
+ * The idea is to inject a thread into the given process that runs either
+ * kernel32!CtrlRoutine() (i.e. the work horse of GenerateConsoleCtrlEvent())
+ * for SIGINT (Ctrl+C) and SIGQUIT (Ctrl+Break), or ExitProcess() for SIGTERM.
+ * This is handled through the console helpers.
+ *
+ * For SIGKILL, we run TerminateProcess() without injecting anything, and this
+ * is also the fall-back when the previous methods are unavailable.
+ *
+ * Note: as kernel32.dll is loaded before any process, the other process and
+ * this process will have ExitProcess() at the same address. The same holds
+ * true for kernel32!CtrlRoutine(), of course, but it is an internal API
+ * function, so we cannot look it up directly. Instead, we launch
+ * getprocaddr.exe to find out and inject the remote thread.
+ *
+ * This function expects the process handle to have the access rights for
+ * CreateRemoteThread(): PROCESS_CREATE_THREAD, PROCESS_QUERY_INFORMATION,
+ * PROCESS_VM_OPERATION, PROCESS_VM_WRITE, and PROCESS_VM_READ.
+ *
+ * The idea for the injected remote thread comes from the Dr Dobb's article "A
+ * Safer Alternative to TerminateProcess()" by Andrew Tucker (July 1, 1999),
+ * http://www.drdobbs.com/a-safer-alternative-to-terminateprocess/184416547.
+ *
+ * The idea to use kernel32!CtrlRoutine for the other signals comes from
+ * SendSignal (https://github.com/AutoSQA/SendSignal/ and
+ * http://stanislavs.org/stopping-command-line-applications-programatically-with-ctrl-c-events-from-net/).
+ */
+
+#include <math.h>
+#include <wchar.h>
+
+#ifndef __INSIDE_CYGWIN__
+/* To help debugging via kill.exe */
+#define small_printf(...) fprintf (stderr, __VA_ARGS__)
+#endif
+
+static BOOL get_wow (HANDLE process, BOOL &is_wow, USHORT &process_arch);
+static int exit_process_tree (HANDLE main_process, int exit_code);
+
+static BOOL
+kill_via_console_helper (HANDLE process, wchar_t *function_name, int exit_code,
+                         DWORD pid)
+{
+  BOOL is_wow;
+  USHORT process_arch;
+  if (!get_wow (process, is_wow, process_arch))
+    {
+      return FALSE;
+    }
+
+  const char *name;
+  switch (process_arch)
+  {
+    case IMAGE_FILE_MACHINE_I386:
+      name = "/usr/libexec/getprocaddr32.exe";
+      break;
+    case IMAGE_FILE_MACHINE_AMD64:
+      name = "/usr/libexec/getprocaddr64.exe";
+      break;
+    /* TODO: provide exes for these */
+    case IMAGE_FILE_MACHINE_ARMNT:
+      name = "/usr/libexec/getprocaddrarm32.exe";
+      break;
+    case IMAGE_FILE_MACHINE_ARM64:
+      name = "/usr/libexec/getprocaddrarm64.exe";
+      break;
+    default:
+      return FALSE; /* what?!? */
+  }
+  wchar_t wbuf[PATH_MAX];
+
+  if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, name, wbuf, PATH_MAX)
+      || GetFileAttributesW (wbuf) == INVALID_FILE_ATTRIBUTES)
+    return FALSE;
+
+  STARTUPINFOW si = {};
+  PROCESS_INFORMATION pi;
+  size_t len = wcslen (wbuf) + 1 /* space */ + wcslen (function_name)
+               + 1 /* space */ + 3 /* exit code */ + 1 /* space */
+               + 10 /* process ID, i.e. DWORD */ + 1 /* NUL */;
+  WCHAR cmd[len + 1];
+  WCHAR title[] = L"cygwin-console-helper";
+  DWORD process_exit;
+
+  swprintf (cmd, len + 1, L"%S %S %d %u", wbuf, function_name, exit_code,
+            pid);
+
+  si.cb = sizeof (si);
+  si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
+  si.wShowWindow = SW_HIDE;
+  si.lpTitle = title;
+  si.hStdInput = si.hStdError = si.hStdOutput = INVALID_HANDLE_VALUE;
+
+  /* Create a new hidden process. */
+  if (!CreateProcessW (NULL, cmd, NULL, NULL, TRUE,
+                       CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP, NULL, NULL,
+                       &si, &pi))
+    {
+      return FALSE;
+    }
+  else
+    {
+      /* Wait for the process to complete for 10 seconds */
+      WaitForSingleObject (pi.hProcess, 10000);
+    }
+
+  if (!GetExitCodeProcess (pi.hProcess, &process_exit))
+    process_exit = -1;
+
+  CloseHandle (pi.hThread);
+  CloseHandle (pi.hProcess);
+
+  return process_exit == 0 ? TRUE : FALSE;
+}
+
+static int current_is_wow = -1;
+static int is_32_bit_os = -1;
+
+typedef BOOL (WINAPI * IsWow64Process2_t) (HANDLE, USHORT *, USHORT *);
+static bool wow64process2initialized = false;
+static IsWow64Process2_t pIsWow64Process2 /* = NULL */;
+
+typedef BOOL (WINAPI * GetProcessInformation_t) (HANDLE,
+                                                 PROCESS_INFORMATION_CLASS,
+                                                 LPVOID, DWORD);
+static bool getprocessinfoinitialized = false;
+static GetProcessInformation_t pGetProcessInformation /* = NULL */;
+
+static BOOL
+get_wow (HANDLE process, BOOL &is_wow, USHORT &process_arch)
+{
+  USHORT native_arch = IMAGE_FILE_MACHINE_UNKNOWN;
+  if (!wow64process2initialized)
+    {
+      pIsWow64Process2 = (IsWow64Process2_t)
+              GetProcAddress (GetModuleHandle ("KERNEL32"),
+                              "IsWow64Process2");
+      MemoryBarrier ();
+      wow64process2initialized = true;
+    }
+  if (!pIsWow64Process2)
+    {
+      if (is_32_bit_os == -1)
+        {
+          SYSTEM_INFO info;
+
+          GetNativeSystemInfo (&info);
+          if (info.wProcessorArchitecture == 0)
+            is_32_bit_os = 1;
+          else if (info.wProcessorArchitecture == 9)
+            is_32_bit_os = 0;
+          else
+            is_32_bit_os = -2;
+        }
+
+      if (current_is_wow == -1
+          && !IsWow64Process (GetCurrentProcess (), &current_is_wow))
+        current_is_wow = -2;
+
+      if (is_32_bit_os == -2 || current_is_wow == -2)
+        return FALSE;
+
+      if (!IsWow64Process (process, &is_wow))
+        return FALSE;
+
+      process_arch = is_32_bit_os || is_wow ? IMAGE_FILE_MACHINE_I386 :
+                                      IMAGE_FILE_MACHINE_AMD64;
+      return TRUE;
+    }
+
+  if (!pIsWow64Process2 (process, &process_arch, &native_arch))
+    return FALSE;
+
+  /* The value will be IMAGE_FILE_MACHINE_UNKNOWN if the target process
+   * is not a WOW64 process
+   */
+  if (process_arch == IMAGE_FILE_MACHINE_UNKNOWN)
+    {
+      struct /* _PROCESS_MACHINE_INFORMATION */
+        {
+          /* 0x0000 */ USHORT ProcessMachine;
+          /* 0x0002 */ USHORT Res0;
+          /* 0x0004 */ DWORD MachineAttributes;
+        } /* size: 0x0008 */ process_machine_info;
+
+      is_wow = FALSE;
+      /* However, x86_64 on ARM64 claims not to be WOW64, so we have to
+       * dig harder... */
+      if (!getprocessinfoinitialized)
+        {
+          pGetProcessInformation = (GetProcessInformation_t)
+                  GetProcAddress (GetModuleHandle ("KERNEL32"),
+                                  "GetProcessInformation");
+          MemoryBarrier ();
+          getprocessinfoinitialized = true;
+        }
+      /*#define ProcessMachineTypeInfo 9*/
+      if (pGetProcessInformation &&
+          pGetProcessInformation (process, (PROCESS_INFORMATION_CLASS)9,
+            &process_machine_info, sizeof (process_machine_info)))
+        process_arch = process_machine_info.ProcessMachine;
+      else
+        process_arch = native_arch;
+    }
+  else
+    {
+      is_wow = TRUE;
+    }
+  return TRUE;
+}
+
+/**
+ * Terminates the process corresponding to the process ID
+ *
+ * This way of terminating the processes is not gentle: the process gets
+ * no chance of cleaning up after itself (closing file handles, removing
+ * .lock files, terminating spawned processes (if any), etc).
+ */
+static int
+exit_process (HANDLE process, int exit_code)
+{
+  LPTHREAD_START_ROUTINE address = NULL;
+  DWORD pid = GetProcessId (process), code;
+  int signo = exit_code & 0x7f;
+  switch (signo)
+    {
+    case SIGINT:
+    case SIGQUIT:
+      /* We are not going to kill them but simply say that Ctrl+C
+      is pressed. If the processes want they can exit or else
+      just wait.*/
+      if (kill_via_console_helper (
+              process, L"CtrlRoutine",
+              signo == SIGINT ? CTRL_C_EVENT : CTRL_BREAK_EVENT, pid))
+        return 0;
+      /* fall-through */
+    case SIGTERM:
+      if (kill_via_console_helper (process, L"ExitProcess", exit_code, pid))
+        return 0;
+      break;
+    default:
+      break;
+    }
+
+  return int (TerminateProcess (process, exit_code));
+}
+
+#include <tlhelp32.h>
+#include <unistd.h>
+
+/**
+ * Terminates the process corresponding to the process ID and all of its
+ * directly and indirectly spawned subprocesses using the
+ * TerminateProcess() function.
+ */
+static int
+exit_process_tree (HANDLE main_process, int exit_code)
+{
+  HANDLE snapshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
+  PROCESSENTRY32 entry;
+  DWORD pids[16384];
+  int max_len = sizeof (pids) / sizeof (*pids), i, len, ret = 0;
+  DWORD pid = GetProcessId (main_process);
+  int signo = exit_code & 0x7f;
+
+  pids[0] = pid;
+  len = 1;
+
+  /*
+   * Even if Process32First()/Process32Next() seem to traverse the
+   * processes in topological order (i.e. parent processes before
+   * child processes), there is nothing in the Win32 API documentation
+   * suggesting that this is guaranteed.
+   *
+   * Therefore, run through them at least twice and stop when no more
+   * process IDs were added to the list.
+   */
+  for (;;)
+    {
+      memset (&entry, 0, sizeof (entry));
+      entry.dwSize = sizeof (entry);
+
+      if (!Process32First (snapshot, &entry))
+        break;
+
+      int orig_len = len;
+      do
+        {
+          /**
+           * Look for the parent process ID in the list of pids to kill, and if
+           * found, add it to the list.
+           */
+          for (i = len - 1; i >= 0; i--)
+            {
+              if (pids[i] == entry.th32ProcessID)
+                break;
+              if (pids[i] != entry.th32ParentProcessID)
+                continue;
+
+              /* We found a process to kill; is it an MSYS2 process? */
+              pid_t cyg_pid = cygwin_winpid_to_pid (entry.th32ProcessID);
+              if (cyg_pid > -1)
+                {
+                  if (cyg_pid == getpgid (cyg_pid))
+                    kill (cyg_pid, signo);
+                  break;
+                }
+              pids[len++] = entry.th32ProcessID;
+              break;
+            }
+        }
+      while (len < max_len && Process32Next (snapshot, &entry));
+
+      if (orig_len == len || len >= max_len)
+        break;
+    }
+
+  CloseHandle (snapshot);
+
+  for (i = len - 1; i >= 0; i--)
+    {
+      HANDLE process;
+
+      if (!i)
+        process = main_process;
+      else
+        {
+          process = OpenProcess (
+              PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION
+                  | PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ,
+              FALSE, pids[i]);
+          if (!process)
+            process = OpenProcess (
+                PROCESS_QUERY_LIMITED_INFORMATION | PROCESS_TERMINATE,
+                FALSE, pids[i]);
+        }
+      DWORD code;
+
+      if (process
+          && (!GetExitCodeProcess (process, &code) || code == STILL_ACTIVE))
+        {
+          if (!exit_process (process, exit_code))
+            ret = -1;
+        }
+      if (process && process != main_process)
+        CloseHandle (process);
+    }
+
+  return ret;
+}
+
+#endif

From 169cc75001e874e7e0cf0b172137604d69218b0d Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Fri, 20 Mar 2015 10:01:50 +0000
Subject: [PATCH 48/84] kill: kill Win32 processes more gently

This change is the equivalent to the change to the Ctrl+C handling we
just made.

Co-authored-by: Naveen M K <naveen@syrusdark.website>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/utils/kill.cc | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/winsup/utils/kill.cc b/winsup/utils/kill.cc
index bcabcd47c9..31ad57a137 100644
--- a/winsup/utils/kill.cc
+++ b/winsup/utils/kill.cc
@@ -17,6 +17,7 @@ details. */
 #include <cygwin/version.h>
 #include <getopt.h>
 #include <limits.h>
+#include <cygwin/exit_process.h>
 
 static char *prog_name;
 
@@ -300,10 +301,20 @@ forcekill (pid_t pid, DWORD winpid, int sig, int wait)
       return;
     }
   if (!wait || WaitForSingleObject (h, 200) != WAIT_OBJECT_0)
-    if (sig && !TerminateProcess (h, sig << 8)
-	&& WaitForSingleObject (h, 200) != WAIT_OBJECT_0)
-      fprintf (stderr, "%s: couldn't kill pid %u, %u\n",
-	       prog_name, (unsigned int) dwpid, (unsigned int) GetLastError ());
+    {
+      HANDLE cur = GetCurrentProcess (), h2;
+      /* duplicate handle with access rights required for exit_process_tree() */
+      if (DuplicateHandle (cur, h, cur, &h2, PROCESS_CREATE_THREAD |
+			      PROCESS_QUERY_INFORMATION |
+			      PROCESS_VM_OPERATION |
+			      PROCESS_VM_WRITE | PROCESS_VM_READ |
+			      PROCESS_TERMINATE, FALSE, 0))
+      {
+        CloseHandle(h);
+        h = h2;
+      }
+      exit_process_tree (h, 128 + sig);
+    }
   CloseHandle (h);
 }
 

From e9c387d31a34c7bf6a67d6ae2a1e70f6cbd68cf5 Mon Sep 17 00:00:00 2001
From: Jeremy Drake <github@jdrake.com>
Date: Thu, 22 Jul 2021 11:59:16 -0700
Subject: [PATCH 49/84] Cygwin: make option for native inner link handling.

This code has been causing issues with SUBST and mapped network drives,
so add an option (defaulted to on) which can be used to disable it where
needed.  MSYS=nonativeinnerlinks
---
 winsup/cygwin/environ.cc | 1 +
 winsup/cygwin/globals.cc | 1 +
 winsup/cygwin/path.cc    | 5 +++--
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/winsup/cygwin/environ.cc b/winsup/cygwin/environ.cc
index b9600ef9a8..06b1111f51 100644
--- a/winsup/cygwin/environ.cc
+++ b/winsup/cygwin/environ.cc
@@ -123,6 +123,7 @@ static struct parse_thing
   {"error_start", {func: error_start_init}, isfunc, NULL, {{0}, {0}}},
   {"export", {&export_settings}, setbool, NULL, {{false}, {true}}},
   {"glob", {func: glob_init}, isfunc, NULL, {{0}, {s: "normal"}}},
+  {"nativeinnerlinks", {&nativeinnerlinks}, setbool, NULL, {{false}, {true}}},
   {"pipe_byte", {&pipe_byte}, setbool, NULL, {{false}, {true}}},
   {"proc_retry", {func: set_proc_retry}, isfunc, NULL, {{0}, {5}}},
   {"reset_com", {&reset_com}, setbool, NULL, {{false}, {true}}},
diff --git a/winsup/cygwin/globals.cc b/winsup/cygwin/globals.cc
index 79f9476330..30a2da1205 100644
--- a/winsup/cygwin/globals.cc
+++ b/winsup/cygwin/globals.cc
@@ -74,6 +74,7 @@ bool wincmdln = true;
 winsym_t allow_winsymlinks = WSYM_deepcopy;
 bool disable_pcon;
 bool winjitdebug = false;
+bool nativeinnerlinks = true;
 
 /* Taken from BSD libc:
    This variable is zero until a process has created a pthread.  It is used
diff --git a/winsup/cygwin/path.cc b/winsup/cygwin/path.cc
index b3426093db..688e7f7c1f 100644
--- a/winsup/cygwin/path.cc
+++ b/winsup/cygwin/path.cc
@@ -3848,8 +3848,9 @@ symlink_info::check (char *path, const suffix_info *suffixes, fs_info &fs,
 	 differ, return the final path as symlink content and set symlen
 	 to a negative value.  This forces path_conv::check to restart
 	 symlink evaluation with the new path. */
-      if ((pc_flags () & (PC_SYM_FOLLOW | PC_SYM_NOFOLLOW_REP))
-	  == PC_SYM_FOLLOW)
+      if (nativeinnerlinks
+	  && (pc_flags () & (PC_SYM_FOLLOW | PC_SYM_NOFOLLOW_REP))
+	      == PC_SYM_FOLLOW)
 	{
 	  PWCHAR fpbuf = tp.w_get ();
 	  DWORD ret;

From 6a898da60fbe5c86ddb4bfee65169812be0a8aea Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Mon, 8 Nov 2021 14:20:07 +0100
Subject: [PATCH 50/84] docs: skip building texinfo and PDF files

The MSYS2 packages lack the infrastructure to build those.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/configure.ac    | 7 +++----
 winsup/doc/Makefile.am | 9 +++------
 2 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/winsup/configure.ac b/winsup/configure.ac
index b9e3977fcf..b88f3ade29 100644
--- a/winsup/configure.ac
+++ b/winsup/configure.ac
@@ -84,11 +84,10 @@ AM_CONDITIONAL(BUILD_DOC, [test $enable_doc != "no"])
 AC_CHECK_PROGS([DOCBOOK2XTEXI], [docbook2x-texi db2x_docbook2texi])
 if test -z "$DOCBOOK2XTEXI" ; then
     if test "x$enable_doc" != "xno"; then
-        AC_MSG_ERROR([docbook2texi is required to build documentation])
-    else
-        unset DOCBOOK2XTEXI
-        AM_MISSING_PROG([DOCBOOK2XTEXI], [docbook2texi])
+        AC_MSG_WARN([docbook2texi is required to build documentation])
     fi
+    unset DOCBOOK2XTEXI
+    AM_MISSING_PROG([DOCBOOK2XTEXI], [docbook2texi])
 fi
 
 AC_CHECK_PROGS([XMLTO], [xmlto])
diff --git a/winsup/doc/Makefile.am b/winsup/doc/Makefile.am
index 650e0c9247..55e9b95e78 100644
--- a/winsup/doc/Makefile.am
+++ b/winsup/doc/Makefile.am
@@ -10,9 +10,7 @@ man1_MANS =
 man3_MANS =
 man5_MANS =
 
-doc_DATA = \
-	cygwin-ug-net/cygwin-ug-net.pdf \
-	cygwin-api/cygwin-api.pdf
+doc_DATA =
 
 htmldir = $(datarootdir)/doc
 
@@ -35,8 +33,7 @@ all-local: Makefile.dep \
 	cygwin-ug-net/cygwin-ug-net.html \
 	faq/faq.html faq/faq.body \
 	cygwin-ug-net/cygwin-ug-net-nochunks.html.gz \
-	api2man.stamp intro2man.stamp utils2man.stamp \
-	cygwin-api.info cygwin-ug-net.info
+	api2man.stamp intro2man.stamp utils2man.stamp
 
 clean-local:
 	rm -f Makefile.dep
@@ -76,7 +73,7 @@ install-etc:
 	@$(MKDIR_P) $(DESTDIR)$(sysconfdir)/preremove
 	$(INSTALL_SCRIPT) $(srcdir)/etc.preremove.cygwin-doc.sh $(DESTDIR)$(sysconfdir)/preremove/cygwin-doc.sh
 
-install-data-hook: install-extra-man install-html-local install-info-local install-etc
+install-data-hook: install-extra-man install-html-local install-etc
 
 uninstall-extra-man:
 	for i in *.1 ; do \

From 65fb4f38608ef9b9ad1d411a9388fd2d2924239e Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Mon, 8 Nov 2021 16:22:57 +0100
Subject: [PATCH 51/84] install-libs: depend on the "toollibs"

Before symlinking libg.a, we need the symlink source `libmsys-2.0.a`: in
MSYS2, we copy by default (if we were creating Unix-style symlinks, the
target would not have to exist before symlinking, but when copying we do
need the source _right away_).

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/Makefile.am | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/winsup/cygwin/Makefile.am b/winsup/cygwin/Makefile.am
index 54ae637450..9c09fc2170 100644
--- a/winsup/cygwin/Makefile.am
+++ b/winsup/cygwin/Makefile.am
@@ -707,7 +707,7 @@ man_MANS = regex/regex.3 regex/regex.7
 install-exec-hook: install-libs
 install-data-local: install-headers install-ldif
 
-install-libs:
+install-libs: install-toollibDATA
 	@$(MKDIR_P) $(DESTDIR)$(bindir)
 	$(INSTALL_PROGRAM) $(NEW_DLL_NAME) $(DESTDIR)$(bindir)/$(DLL_NAME)
 	@$(MKDIR_P) $(DESTDIR)$(toollibdir)

From 4d520fc0f5115ccba0d4c7ce726d846eb00547a6 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Mon, 23 Nov 2015 20:03:11 +0100
Subject: [PATCH 52/84] POSIX-ify the SHELL variable

When calling a non-MSys2 binary, all of the environment is converted from
POSIX to Win32, including the SHELL environment variable. In Git for
Windows, for example, `SHELL=/usr/bin/bash` is converted to
`SHELL=C:\Program Files\Git\usr\bin\bash.exe` when calling the `git.exe`
binary. This is appropriate because non-MSys2 binaries would not handle
POSIX paths correctly.

Under certain circumstances, however, `git.exe` calls an *MSys2* binary in
turn, such as `git config --edit` calling `vim.exe` unless Git is
configured to use another editor specifically.

Now, when this "improved vi" calls shell commands, it uses that $SHELL
variable *without quoting*, resulting in a nasty error:

	C:\Program: No such file or directory

Many other programs behave in the same manner, assuming that $SHELL does
not contain spaces and hence needs no quoting, unfortunately including
some of Git's own scripts.

Therefore let's make sure that $SHELL gets "posified" again when entering
MSys2 programs.

Earlier attempts by Git for Windows contributors claimed that adding
`SHELL` to the `conv_envvars` array does not have the intended effect.
These reports just missed that the `conv_start_chars` array (which makes
the code more performant) needs to be adjusted, too.

Note that we set the `immediate` flag to `true` so that the environment
variable is set immediately by the MSys2 runtime, i.e. not only spawned
processes will see the POSIX-ified `SHELL` variable, but the MSys2 runtime
*itself*, too.

This fixes https://github.com/git-for-windows/git/issues/542,
https://github.com/git-for-windows/git/issues/498, and
https://github.com/git-for-windows/git/issues/468.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/environ.cc               | 8 +++++++-
 winsup/cygwin/local_includes/environ.h | 2 +-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/winsup/cygwin/environ.cc b/winsup/cygwin/environ.cc
index 06b1111f51..e21c8fddb9 100644
--- a/winsup/cygwin/environ.cc
+++ b/winsup/cygwin/environ.cc
@@ -323,6 +323,7 @@ static win_env conv_envvars[] =
     {NL ("HOME="), NULL, NULL, env_path_to_posix, env_path_to_win32, false},
     {NL ("LD_LIBRARY_PATH="), NULL, NULL,
 			       env_plist_to_posix, env_plist_to_win32, true},
+    {NL ("SHELL="), NULL, NULL, env_path_to_posix, env_path_to_win32, true, true},
     {NL ("TMPDIR="), NULL, NULL, env_path_to_posix, env_path_to_win32, false},
     {NL ("TMP="), NULL, NULL, env_path_to_posix, env_path_to_win32, false},
     {NL ("TEMP="), NULL, NULL, env_path_to_posix, env_path_to_win32, false},
@@ -351,7 +352,7 @@ static const unsigned char conv_start_chars[256] =
     WC,       0,        0,        0,        WC,       0,        0,        0,
     /*  80 */
 /*  P         Q         R         S         T         U         V         W */
-    WC,       0,        0,        0,        WC,       0,        0,        0,
+    WC,       0,        0,        WC,       WC,       0,        0,        0,
     /*  88 */
 /*  x         Y         Z                                                   */
     0,        0,        0,        0,        0,        0,        0,        0,
@@ -380,6 +381,7 @@ win_env::operator = (struct win_env& x)
   toposix = x.toposix;
   towin32 = x.towin32;
   immediate = false;
+  skip_if_empty = x.skip_if_empty;
   return *this;
 }
 
@@ -401,6 +403,8 @@ win_env::add_cache (const char *in_posix, const char *in_native)
       native = (char *) realloc (native, namelen + 1 + strlen (in_native));
       stpcpy (stpcpy (native, name), in_native);
     }
+  else if (skip_if_empty && !*in_posix)
+    native = (char *) calloc(1, 1);
   else
     {
       tmp_pathbuf tp;
@@ -466,6 +470,8 @@ posify_maybe (char **here, const char *value, char *outenv)
     return;
 
   int len = strcspn (src, "=") + 1;
+  if (conv->skip_if_empty && !src[len])
+    return;
 
   /* Turn all the items from c:<foo>;<bar> into their
      mounted equivalents - if there is one.  */
diff --git a/winsup/cygwin/local_includes/environ.h b/winsup/cygwin/local_includes/environ.h
index 0dd45359cc..fd6ca466e8 100644
--- a/winsup/cygwin/local_includes/environ.h
+++ b/winsup/cygwin/local_includes/environ.h
@@ -21,7 +21,7 @@ struct win_env
     char *native;
     ssize_t (*toposix) (const void *, void *, size_t);
     ssize_t (*towin32) (const void *, void *, size_t);
-    bool immediate;
+    bool immediate, skip_if_empty;
     void add_cache (const char *in_posix, const char *in_native = NULL);
     const char * get_native () const {return native ? native + namelen : NULL;}
     const char * get_posix () const {return posix ? posix : NULL;}

From ad95c5cf97830718ca8aa65fd390196036322c6c Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Tue, 21 Mar 2017 13:18:38 +0100
Subject: [PATCH 53/84] Handle ORIGINAL_PATH just like PATH

MSYS2 recently introduced that hack where the ORIGINAL_PATH variable is
set to the original PATH value in /etc/profile, unless previously set.
In Git for Windows' default mode, that ORIGINAL_PATH value is the used
to define the PATH variable explicitly.

So far so good.

The problem: when calling from inside an MSYS2 process (such as Bash) a
MINGW executable (such as git.exe) that then calls another MSYS2
executable (such as bash.exe), that latter call will try to re-convert
ORIGINAL_PATH after the previous call converted ORIGINAL_PATH from POSIX
to Windows paths. And this conversion may very well fail, e.g. when the
path list contains mixed semicolons and colons.

So let's just *force* the MSYS2 runtime to handle ORIGINAL_PATH in the
same way as the PATH variable (which conversion works, as we know).

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/environ.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/winsup/cygwin/environ.cc b/winsup/cygwin/environ.cc
index e21c8fddb9..031db039ea 100644
--- a/winsup/cygwin/environ.cc
+++ b/winsup/cygwin/environ.cc
@@ -323,6 +323,7 @@ static win_env conv_envvars[] =
     {NL ("HOME="), NULL, NULL, env_path_to_posix, env_path_to_win32, false},
     {NL ("LD_LIBRARY_PATH="), NULL, NULL,
 			       env_plist_to_posix, env_plist_to_win32, true},
+    {NL ("ORIGINAL_PATH="), NULL, NULL, env_PATH_to_posix, env_plist_to_win32, true},
     {NL ("SHELL="), NULL, NULL, env_path_to_posix, env_path_to_win32, true, true},
     {NL ("TMPDIR="), NULL, NULL, env_path_to_posix, env_path_to_win32, false},
     {NL ("TMP="), NULL, NULL, env_path_to_posix, env_path_to_win32, false},
@@ -349,7 +350,7 @@ static const unsigned char conv_start_chars[256] =
     0,        0,        0,        0,        0,        0,        0,        0,
     /*  72 */
 /*  H         I         J         K         L         M         N         O */
-    WC,       0,        0,        0,        WC,       0,        0,        0,
+    WC,       0,        0,        0,        WC,       0,        0,        WC,
     /*  80 */
 /*  P         Q         R         S         T         U         V         W */
     WC,       0,        0,        WC,       WC,       0,        0,        0,

From 54f7f41a8a06a7569b1edd545a26c878f2d63965 Mon Sep 17 00:00:00 2001
From: Christoph Reiter <reiter.christoph@gmail.com>
Date: Sun, 3 Jul 2022 22:39:32 +0200
Subject: [PATCH 54/84] uname: allow setting the system name to CYGWIN

We are currently trying to move our cygwin build environment closer
to cygwin and some autotools/bash based build systems call "uname -s"
to figure out the OS and in many cases only handle the cygwin case, so
we have to patch them.

With this instead of patching we can set MSYSTEM=CYGWIN and change
uname output that way.

The next step would be to always output CYGWIN in an msys env by default,
but for now this allows us to get rid of all the patches without
affecting users.
---
 winsup/cygwin/uname.cc | 36 ++++++++++++++++++++++--------------
 1 file changed, 22 insertions(+), 14 deletions(-)

diff --git a/winsup/cygwin/uname.cc b/winsup/cygwin/uname.cc
index ed4c9c59a1..cca66be45a 100644
--- a/winsup/cygwin/uname.cc
+++ b/winsup/cygwin/uname.cc
@@ -24,6 +24,24 @@ extern "C" int getdomainname (char *__name, size_t __len);
 #define ATTRIBUTE_NONSTRING
 #endif
 
+static const char*
+get_sysname()
+{
+#ifdef __MSYS__
+  char* msystem = getenv("MSYSTEM");
+  if (!msystem || strcmp(msystem, "MSYS") == 0)
+    return "MSYS";
+  else if (strcmp(msystem, "CYGWIN") == 0)
+    return "CYGWIN";
+  else if (strstr(msystem, "32") != NULL)
+    return "MINGW32";
+  else
+    return "MINGW64";
+#else
+  return "CYGWIN";
+#endif
+}
+
 /* uname: POSIX 4.4.1.1 */
 
 /* New entrypoint for applications since API 335 */
@@ -37,12 +55,9 @@ uname_x (struct utsname *name)
 
       memset (name, 0, sizeof (*name));
       /* sysname */
-      char* msystem = getenv("MSYSTEM");
-      const char* msystem_sysname = "MSYS";
-      if (msystem != NULL && *msystem && strcmp(msystem, "MSYS") != 0)
-        msystem_sysname = (strstr(msystem, "32") != NULL) ? "MINGW32" : "MINGW64";;
+      const char* sysname = get_sysname();
       n = __small_sprintf (name->sysname, "%s_%s-%u",
-			   msystem_sysname,
+			   sysname,
 			   wincap.osname (), wincap.build_number ());
       if (wincap.host_machine () != wincap.cygwin_machine ())
 	{
@@ -123,15 +138,8 @@ uname (struct utsname *in_name)
   __try
     {
       memset (name, 0, sizeof (*name));
-#ifdef __MSYS__
-      char* msystem = getenv("MSYSTEM");
-      const char* msystem_sysname = "MSYS";
-      if (msystem != NULL && *msystem && strcmp(msystem, "MSYS") != 0)
-        msystem_sysname = (strstr(msystem, "32") != NULL) ? "MINGW32" : "MINGW64";
-      __small_sprintf (name->sysname, "%s_%s", msystem_sysname, wincap.osname ());
-#else
-      __small_sprintf (name->sysname, "CYGWIN_%s", wincap.osname ());
-#endif
+      const char* sysname = get_sysname();
+      __small_sprintf (name->sysname, "%s_%s", sysname, wincap.osname ());
 
       /* Computer name */
       cygwin_gethostname (name->nodename, sizeof (name->nodename) - 1);

From b4f031fd886c18e8e3a9dc02e236525b2469f756 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Wed, 18 Feb 2015 12:32:17 +0000
Subject: [PATCH 55/84] Pass environment variables with empty values

There is a difference between an empty value and an unset environment
variable. We should not confuse both; If the user wants to unset an
environment variable, they can certainly do so (unsetenv(3), or in the
shell: 'unset ABC').

This fixes Git's t3301-notes.sh, which overrides environment variables
with empty values.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/environ.cc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/winsup/cygwin/environ.cc b/winsup/cygwin/environ.cc
index 031db039ea..6b385cd03d 100644
--- a/winsup/cygwin/environ.cc
+++ b/winsup/cygwin/environ.cc
@@ -1326,11 +1326,11 @@ build_env (const char * const *envp, PWCHAR &envblock, int &envc,
 	     Note that this doesn't stop invalid strings without '=' in it
 	     etc., but we're opting for speed here for now.  Adding complete
 	     checking would be pretty expensive. */
-	  if (len == 1 || !*rest)
+	  if (len == 1)
 	    continue;
 
 	  /* See if this entry requires posix->win32 conversion. */
-	  conv = getwinenv (*srcp, rest, &temp);
+	  conv = !*rest ? NULL : getwinenv (*srcp, rest, &temp);
 	  if (conv)
 	    {
 	      p = conv->native;	/* Use win32 path */
@@ -1344,7 +1344,7 @@ build_env (const char * const *envp, PWCHAR &envblock, int &envc,
 		}
 	    }
 #ifdef __MSYS__
-	  else if (!keep_posix) {
+	  else if (!keep_posix && *rest) {
 	    char *win_arg = arg_heuristic_with_exclusions
 		   (*srcp, msys2_env_conv_excl_env, msys2_env_conv_excl_count);
 	    debug_printf("WIN32_PATH is %s", win_arg);

From 4a7fa0d252da2d853aeb08eac42cf6bdfc54a84a Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Tue, 6 Sep 2022 10:40:58 +0200
Subject: [PATCH 56/84] Optionally disallow empty environment values again

We just disabled the code that skips environment variables whose values
are empty.

However, this code was introduced a long time ago into Cygwin in
d6b1ac7faa (* environ.cc (build_env): Don't put an empty environment
variable into the environment.  Optimize use of "len". * errno.cc
(ERROR_MORE_DATA): Translate to EMSGSIZE rather than EAGAIN.,
2006-09-07), seemingly without any complaints.

Meaning: There might very well be use cases out there where it makes
sense to skip empty-valued environment variables.

Therefore, it seems like a good idea to have a "knob" to turn it back
on. With this commit, we introduce such a knob: by setting
`noemptyenvvalues` the `MSYS` variable (or appending it if that variable
is already set), users can tell the MSYS2 runtime to behave just like in
the olden times.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/environ.cc | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/winsup/cygwin/environ.cc b/winsup/cygwin/environ.cc
index 6b385cd03d..12b4d57563 100644
--- a/winsup/cygwin/environ.cc
+++ b/winsup/cygwin/environ.cc
@@ -36,6 +36,7 @@ static char **lastenviron;
 /* Parse CYGWIN options */
 
 static NO_COPY bool export_settings = false;
+static bool emptyenvvalues = true;
 
 enum settings
   {
@@ -119,6 +120,7 @@ static struct parse_thing
   } known[] NO_COPY =
 {
   {"disable_pcon", {&disable_pcon}, setbool, NULL, {{false}, {true}}},
+  {"emptyenvvalues", {&emptyenvvalues}, setbool, NULL, {{false}, {true}}},
   {"enable_pcon", {&disable_pcon}, setnegbool, NULL, {{true}, {false}}},
   {"error_start", {func: error_start_init}, isfunc, NULL, {{0}, {0}}},
   {"export", {&export_settings}, setbool, NULL, {{false}, {true}}},
@@ -1326,7 +1328,7 @@ build_env (const char * const *envp, PWCHAR &envblock, int &envc,
 	     Note that this doesn't stop invalid strings without '=' in it
 	     etc., but we're opting for speed here for now.  Adding complete
 	     checking would be pretty expensive. */
-	  if (len == 1)
+	  if (len == 1 || (!emptyenvvalues && !*rest))
 	    continue;
 
 	  /* See if this entry requires posix->win32 conversion. */

From 9bf14b59a047b0af4e472f2467576f2095428809 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Tue, 6 Sep 2022 12:18:18 +0200
Subject: [PATCH 57/84] build_env(): respect the `MSYS` environment variable

With this commit, you can call

	MSYS=noemptyenvvalues my-command

and it does what is expected: to pass no empty-valued environment
variables to `my-command`.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/environ.cc | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/winsup/cygwin/environ.cc b/winsup/cygwin/environ.cc
index 12b4d57563..4e049211e9 100644
--- a/winsup/cygwin/environ.cc
+++ b/winsup/cygwin/environ.cc
@@ -1204,7 +1204,11 @@ build_env (const char * const *envp, PWCHAR &envblock, int &envc,
     {
       bool calc_tl = !no_envblock;
 #ifdef __MSYS__
-      if (!keep_posix)
+      if (ascii_strncasematch(*srcp, "MSYS=", 5))
+        {
+          parse_options (*srcp + 5);
+	}
+      else if (!keep_posix)
         {
           /* Don't pass timezone environment to non-msys applications */
           if (ascii_strncasematch(*srcp, "TZ=", 3))

From 65ae61ddc90544b6a34c8377e227c0df014fcf07 Mon Sep 17 00:00:00 2001
From: Christoph Reiter <reiter.christoph@gmail.com>
Date: Sat, 17 Dec 2022 20:14:49 +0100
Subject: [PATCH 58/84] Revert "Cygwin: Enable dynamicbase on the Cygwin DLL by
 default"

This reverts commit 943433b00cacdde0cb9507d0178770a2fb67bd71.

This seems to fix fork errors under Docker, see
https://cygwin.com/pipermail/cygwin/2022-December/252711.html
---
 winsup/cygwin/Makefile.am | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/winsup/cygwin/Makefile.am b/winsup/cygwin/Makefile.am
index 9c09fc2170..140e01a12b 100644
--- a/winsup/cygwin/Makefile.am
+++ b/winsup/cygwin/Makefile.am
@@ -605,8 +605,7 @@ $(NEW_DLL_NAME): $(LDSCRIPT) libdll.a $(VERSION_OFILES) $(LIBSERVER)\
 		  $(newlib_build)/libm.a $(newlib_build)/libc.a
 	$(AM_V_CXXLD)$(CXX) $(CXXFLAGS) \
 	-mno-use-libstdc-wrappers \
-	-Wl,--gc-sections -nostdlib -Wl,-T$(LDSCRIPT) \
-	-Wl,--dynamicbase -static \
+	-Wl,--gc-sections -nostdlib -Wl,-T$(LDSCRIPT) -static \
 	$${SOURCE_DATE_EPOCH:+-Wl,--no-insert-timestamp} \
 	-Wl,--heap=0 -Wl,--out-implib,msysdll.a -shared -o $@ \
 	-e @DLL_ENTRY@ $(DEF_FILE) \

From 4a74e2f9fbf13775d5c4d064f05a4586f5bd2fa8 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Mon, 30 Jan 2023 23:22:22 +0100
Subject: [PATCH 59/84] Avoid sharing cygheaps across Cygwin versions

It frequently leads to problems when trying, say, to call from MSYS2's
Bash into Cygwin's or Git for Windows', merely because sharing that data
is pretty finicky.

For example, using the MSYS2' Bash using the MSYS2 runtime version that
is current at time of writing, trying to call Cygwin's programs fails
in manners like this:

    $ /c/cygwin64/bin/uname -r
      0 [main] uname (9540) child_copy: cygheap read copy failed, 0x800000000..0x800010BE0, done 0, windows pid 9540, Win32 error 6
    680 [main] uname 880 C:\cygwin64\bin\uname.exe: *** fatal error - couldn't create signal pipe, Win32 error 5

with the rather misleading exit code 127 (a code which is reserved to
indicate that a command was not found).

Let's just treat the MSYS2 runtime and the Cygwin runtime as completely
incompatible with one another, by virtue of using a different
magic constant than merely `CHILD_INFO_MAGIC`.

By using the msys2-runtime commit to modify that magic constant, we can
even spawn programs using a different MSYS2 runtime (such as Git for
Windows') because the commit serves as the tell-tale whether two MSYS2
runtime versions are compatible with each other. To support building in
the MSYS2-packages repository (where we do not check out the
`msys2-runtime` but instead check out Cygwin and apply patches on top),
let's accept a hard-coded commit hash as `./configure` option.

One consequence is that spawned MSYS processes using a different MSYS2
runtime will not be visible as such to the parent process, i.e. they
cannot share any resources such as pseudo terminals. But that's okay,
they are simply treated as if they were regular Win32 programs.

Note: We have to use a very rare form of encoding the brackets in the
`expr` calls: quadrigraphs (for a thorough explanation, see
https://www.gnu.org/savannah-checkouts/gnu/autoconf/manual/autoconf-2.70/html_node/Quadrigraphs.html#Quadrigraphs).
This is necessary because it is apparently impossible to encode brackets
in `configure.ac` files otherwise.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/configure.ac       | 28 ++++++++++++++++++++++++++++
 winsup/cygwin/Makefile.am |  3 +++
 winsup/cygwin/dcrt0.cc    |  2 +-
 winsup/cygwin/sigproc.cc  |  2 +-
 4 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/winsup/configure.ac b/winsup/configure.ac
index b88f3ade29..3aa2b16bf8 100644
--- a/winsup/configure.ac
+++ b/winsup/configure.ac
@@ -57,6 +57,34 @@ AC_CHECK_TOOL(RANLIB, ranlib, ranlib)
 AC_CHECK_TOOL(STRIP, strip, strip)
 AC_CHECK_TOOL(WINDRES, windres, windres)
 
+# Record msys2-runtime commit
+AC_ARG_WITH([msys2-runtime-commit],
+  [AS_HELP_STRING([--with-msys2-runtime-commit=COMMIT],
+		  [indicate the msys2-runtime commit corresponding to this build])],
+  [MSYS2_RUNTIME_COMMIT=$withval], [MSYS2_RUNTIME_COMMIT=yes])
+case "$MSYS2_RUNTIME_COMMIT" in
+no)
+    MSYS2_RUNTIME_COMMIT=
+    MSYS2_RUNTIME_COMMIT_HEX=0
+    ;;
+yes|auto)
+    if MSYS2_RUNTIME_COMMIT="$(git --git-dir="$srcdir/../.git" rev-parse HEAD)"
+    then
+        MSYS2_RUNTIME_COMMIT_HEX="0x$(expr "$MSYS2_RUNTIME_COMMIT" : '\(.\{,8\}\)')ull"
+    else
+        AC_MSG_WARN([Could not determine msys2-runtime commit])
+        MSYS2_RUNTIME_COMMIT=
+        MSYS2_RUNTIME_COMMIT_HEX=0
+    fi
+    ;;
+*)
+    expr "$MSYS2_RUNTIME_COMMIT" : '@<:@0-9a-f@:>@\{6,64\}$' ||
+    AC_MSG_ERROR([Invalid commit name: "$MSYS2_RUNTIME_COMMIT"])
+    MSYS2_RUNTIME_COMMIT_HEX="0x$(expr "$MSYS2_RUNTIME_COMMIT" : '\(.\{,8\}\)')ull"
+    ;;
+esac
+AC_SUBST(MSYS2_RUNTIME_COMMIT_HEX)
+
 AC_ARG_ENABLE(debugging,
 [AS_HELP_STRING([--enable-debugging],[Build a cygwin DLL which has more consistency checking for debugging])],
 [case "${enableval}" in
diff --git a/winsup/cygwin/Makefile.am b/winsup/cygwin/Makefile.am
index 140e01a12b..58ef25dfe5 100644
--- a/winsup/cygwin/Makefile.am
+++ b/winsup/cygwin/Makefile.am
@@ -17,6 +17,9 @@ if TARGET_X86_64
 COMMON_CFLAGS+=-mcmodel=small
 endif
 
+VERSION_CFLAGS = -DMSYS2_RUNTIME_COMMIT_HEX="@MSYS2_RUNTIME_COMMIT_HEX@"
+COMMON_CFLAGS += $(VERSION_CFLAGS)
+
 AM_CFLAGS=$(cflags_common) $(COMMON_CFLAGS)
 AM_CXXFLAGS=$(cxxflags_common) $(COMMON_CFLAGS) -fno-threadsafe-statics
 
diff --git a/winsup/cygwin/dcrt0.cc b/winsup/cygwin/dcrt0.cc
index 4d622cdc28..33cad1e3fe 100644
--- a/winsup/cygwin/dcrt0.cc
+++ b/winsup/cygwin/dcrt0.cc
@@ -531,7 +531,7 @@ get_cygwin_startup_info ()
   child_info *res = (child_info *) si.lpReserved2;
 
   if (si.cbReserved2 < EXEC_MAGIC_SIZE || !res
-      || res->intro != PROC_MAGIC_GENERIC || res->magic != CHILD_INFO_MAGIC)
+      || res->intro != PROC_MAGIC_GENERIC || res->magic != (CHILD_INFO_MAGIC ^ MSYS2_RUNTIME_COMMIT_HEX))
     {
       strace.activate (false);
       res = NULL;
diff --git a/winsup/cygwin/sigproc.cc b/winsup/cygwin/sigproc.cc
index 30779cf8ed..5caf97e7a6 100644
--- a/winsup/cygwin/sigproc.cc
+++ b/winsup/cygwin/sigproc.cc
@@ -893,7 +893,7 @@ int child_info::retry_count = 0;
 child_info::child_info (unsigned in_cb, child_info_types chtype,
 			bool need_subproc_ready):
   msv_count (0), cb (in_cb), intro (PROC_MAGIC_GENERIC),
-  magic (CHILD_INFO_MAGIC), type (chtype), cygheap (::cygheap),
+  magic (CHILD_INFO_MAGIC ^ MSYS2_RUNTIME_COMMIT_HEX), type (chtype), cygheap (::cygheap),
   cygheap_max (::cygheap_max), flag (0), retry (child_info::retry_count),
   rd_proc_pipe (NULL), wr_proc_pipe (NULL), subproc_ready (NULL),
   sigmask (_my_tls.sigmask)

From 5baa55c491e821d0f2f88b408a235d34bd1684e1 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Tue, 21 Feb 2023 16:36:36 +0100
Subject: [PATCH 60/84] uname: report msys2-runtime commit hash, too

Having just Cygwin's version in the output of `uname` is not helpful, as
both MSYS2 as well as Git for Windows release intermediate versions of
the MSYS2 runtime much more often than Cygwin runtime versions are
released.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/configure.ac             | 10 ++++++++--
 winsup/cygwin/Makefile.am       |  6 ++++--
 winsup/cygwin/scripts/mkvers.sh |  8 ++++++++
 winsup/cygwin/uname.cc          | 16 +++++++++-------
 4 files changed, 29 insertions(+), 11 deletions(-)

diff --git a/winsup/configure.ac b/winsup/configure.ac
index 3aa2b16bf8..4dd5ccb9f9 100644
--- a/winsup/configure.ac
+++ b/winsup/configure.ac
@@ -65,24 +65,30 @@ AC_ARG_WITH([msys2-runtime-commit],
 case "$MSYS2_RUNTIME_COMMIT" in
 no)
     MSYS2_RUNTIME_COMMIT=
+    MSYS2_RUNTIME_COMMIT_SHORT=
     MSYS2_RUNTIME_COMMIT_HEX=0
     ;;
 yes|auto)
     if MSYS2_RUNTIME_COMMIT="$(git --git-dir="$srcdir/../.git" rev-parse HEAD)"
     then
-        MSYS2_RUNTIME_COMMIT_HEX="0x$(expr "$MSYS2_RUNTIME_COMMIT" : '\(.\{,8\}\)')ull"
+        MSYS2_RUNTIME_COMMIT_SHORT="$(expr "$MSYS2_RUNTIME_COMMIT" : '\(.\{,8\}\)')"
+        MSYS2_RUNTIME_COMMIT_HEX="0x${MSYS2_RUNTIME_COMMIT_SHORT}ul"
     else
         AC_MSG_WARN([Could not determine msys2-runtime commit])
         MSYS2_RUNTIME_COMMIT=
+        MSYS2_RUNTIME_COMMIT_SHORT=
         MSYS2_RUNTIME_COMMIT_HEX=0
     fi
     ;;
 *)
     expr "$MSYS2_RUNTIME_COMMIT" : '@<:@0-9a-f@:>@\{6,64\}$' ||
     AC_MSG_ERROR([Invalid commit name: "$MSYS2_RUNTIME_COMMIT"])
-    MSYS2_RUNTIME_COMMIT_HEX="0x$(expr "$MSYS2_RUNTIME_COMMIT" : '\(.\{,8\}\)')ull"
+    MSYS2_RUNTIME_COMMIT_SHORT="$(expr "$MSYS2_RUNTIME_COMMIT" : '\(.\{,8\}\)')"
+    MSYS2_RUNTIME_COMMIT_HEX="0x${MSYS2_RUNTIME_COMMIT_SHORT}ul"
     ;;
 esac
+AC_SUBST(MSYS2_RUNTIME_COMMIT)
+AC_SUBST(MSYS2_RUNTIME_COMMIT_SHORT)
 AC_SUBST(MSYS2_RUNTIME_COMMIT_HEX)
 
 AC_ARG_ENABLE(debugging,
diff --git a/winsup/cygwin/Makefile.am b/winsup/cygwin/Makefile.am
index 58ef25dfe5..41190bdb7a 100644
--- a/winsup/cygwin/Makefile.am
+++ b/winsup/cygwin/Makefile.am
@@ -17,7 +17,9 @@ if TARGET_X86_64
 COMMON_CFLAGS+=-mcmodel=small
 endif
 
-VERSION_CFLAGS = -DMSYS2_RUNTIME_COMMIT_HEX="@MSYS2_RUNTIME_COMMIT_HEX@"
+VERSION_CFLAGS = -DMSYS2_RUNTIME_COMMIT="\"@MSYS2_RUNTIME_COMMIT@\""
+VERSION_CFLAGS += -DMSYS2_RUNTIME_COMMIT_SHORT="\"@MSYS2_RUNTIME_COMMIT_SHORT@\""
+VERSION_CFLAGS += -DMSYS2_RUNTIME_COMMIT_HEX="@MSYS2_RUNTIME_COMMIT_HEX@"
 COMMON_CFLAGS += $(VERSION_CFLAGS)
 
 AM_CFLAGS=$(cflags_common) $(COMMON_CFLAGS)
@@ -454,7 +456,7 @@ uname_version.c: .FORCE
 version.cc: scripts/mkvers.sh include/cygwin/version.h winver.rc $(src_files)
 	@echo "Making version.cc and winver.o";\
 	export CC="$(CC)";\
-	/bin/sh $(word 1,$^) $(word 2,$^) $(word 3,$^) $(WINDRES) $(CFLAGS)
+	/bin/sh $(word 1,$^) $(word 2,$^) $(word 3,$^) $(WINDRES) $(CFLAGS) $(VERSION_CFLAGS)
 
 winver.o: version.cc
 
diff --git a/winsup/cygwin/scripts/mkvers.sh b/winsup/cygwin/scripts/mkvers.sh
index a3d45c5db0..34d8d6dce1 100755
--- a/winsup/cygwin/scripts/mkvers.sh
+++ b/winsup/cygwin/scripts/mkvers.sh
@@ -16,6 +16,7 @@ incfile="$1"; shift
 rcfile="$1"; shift
 windres="$1"; shift
 iflags=
+msys2_runtime_commit=
 # Find header file locations
 while [ -n "$*" ]; do
   case "$1" in
@@ -26,6 +27,9 @@ while [ -n "$*" ]; do
     shift
     iflags="$iflags -I$1"
       ;;
+  -DMSYS2_RUNTIME_COMMIT=*)
+    msys2_runtime_commit="${1#*=}"
+    ;;
   esac
   shift
 done
@@ -168,6 +172,10 @@ then
   cvs_tag="$(echo $wv_cvs_tag | sed -e 's/-branch.*//')"
   cygwin_ver="$cygwin_ver-$cvs_tag"
 fi
+if [ -n "$msys2_runtime_commit" ]
+then
+  cygwin_ver="$cygwin_ver-$msys2_runtime_commit"
+fi
 
 echo "Version $cygwin_ver"
 set -$- $builddate
diff --git a/winsup/cygwin/uname.cc b/winsup/cygwin/uname.cc
index cca66be45a..8f984fac9b 100644
--- a/winsup/cygwin/uname.cc
+++ b/winsup/cygwin/uname.cc
@@ -91,18 +91,19 @@ uname_x (struct utsname *name)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wformat-truncation="
 #ifdef CYGPORT_RELEASE_INFO
-      snprintf (name->release, _UTSNAME_LENGTH, "%s.%s",
-		__XSTRING (CYGPORT_RELEASE_INFO), name->machine);
+      snprintf (name->release, _UTSNAME_LENGTH, "%s-%s.%s",
+		__XSTRING (CYGPORT_RELEASE_INFO), MSYS2_RUNTIME_COMMIT_SHORT, name->machine);
 #else
       extern const char *uname_dev_version;
       if (uname_dev_version && uname_dev_version[0])
-	snprintf (name->release, _UTSNAME_LENGTH, "%s.%s",
-		  uname_dev_version, name->machine);
+	snprintf (name->release, _UTSNAME_LENGTH, "%s-%s.%s",
+		  uname_dev_version, MSYS2_RUNTIME_COMMIT_SHORT, name->machine);
       else
-	__small_sprintf (name->release, "%d.%d.%d-api-%d.%s",
+	__small_sprintf (name->release, "%d.%d.%d-%s-api-%d.%s",
 			 cygwin_version.dll_major / 1000,
 			 cygwin_version.dll_major % 1000,
 			 cygwin_version.dll_minor,
+			 MSYS2_RUNTIME_COMMIT_SHORT,
 			 cygwin_version.api_minor,
 			 name->machine);
 #endif
@@ -145,14 +146,15 @@ uname (struct utsname *in_name)
       cygwin_gethostname (name->nodename, sizeof (name->nodename) - 1);
 
       /* Cygwin dll release */
-      __small_sprintf (name->release, "%d.%d.%d(%d.%d/%d/%d)",
+      __small_sprintf (name->release, "%d.%d.%d(%d.%d/%d/%d/%s)",
 		       cygwin_version.dll_major / 1000,
 		       cygwin_version.dll_major % 1000,
 		       cygwin_version.dll_minor,
 		       cygwin_version.api_major,
 		       cygwin_version.api_minor,
 		       cygwin_version.shared_data,
-		       cygwin_version.mount_registry);
+		       cygwin_version.mount_registry,
+		       MSYS2_RUNTIME_COMMIT_SHORT);
 
       /* Cygwin "version" aka build date */
       strcpy (name->version, cygwin_version.dll_build_date);

From 0eeda3e131b580df38367f3c71df2cea2c18ee50 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Mon, 22 May 2023 13:36:27 +0200
Subject: [PATCH 61/84] Cygwin: Adjust CWD magic to accommodate for the latest
 Windows previews

Reportedly a very recent internal build of Windows 11 once again changed
the current working directory logic a bit, and Cygwin's "magic" (or:
"technologically sufficiently advanced") code needs to be adjusted
accordingly.

In particular, the following assembly code can be seen:

ntdll!RtlpReferenceCurrentDirectory

  598 00000001`800c6925 488d0db4cd0f00  lea     rcx,[ntdll!FastPebLock (00000001`801c36e0)]
  583 00000001`800c692c 4c897810        mov     qword ptr [rax+10h],r15
  588 00000001`800c6930 0f1140c8        movups  xmmword ptr [rax-38h],xmm0
  598 00000001`800c6934 e82774f4ff      call    ntdll!RtlEnterCriticalSection

The change necessarily looks a bit different than 4840a56325 (Cygwin:
Adjust CWD magic to accommodate for the latest Windows previews,
2023-05-22): The needle `\x48\x8d\x0d` is already present, as the first
version of the hack after Windows 8.1 was released. In that code,
though, the `call` to `RtlEnterCriticalSection` followed the `lea`
instruction immediately, but now there are two more instructions
separating them.

Note: In the long run, we may very well want to follow the insightful
suggestion by a helpful Windows kernel engineer who pointed out that it
may be less fragile to implement kind of a disassembler that has a
better chance to adapt to the ever-changing code of
`ntdll!RtlpReferenceCurrentDirectory` by skipping uninteresting
instructions such as `mov %rsp,%rax`, `mov %rbx,0x20(%rax)`, `push %rsi`
`sub $0x70,%rsp`, etc, and focuses on finding the `lea`, `call
ntdll!RtlEnterCriticalSection` and `mov ..., rbx` instructions, much
like it was prototyped out for ARM64 at
https://gist.github.com/jeremyd2019/aa167df0a0ae422fa6ebaea5b60c80c9

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/path.cc | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/winsup/cygwin/path.cc b/winsup/cygwin/path.cc
index 688e7f7c1f..c1298a4c24 100644
--- a/winsup/cygwin/path.cc
+++ b/winsup/cygwin/path.cc
@@ -4899,6 +4899,18 @@ find_fast_cwd_pointer ()
          %rcx for the subsequent RtlEnterCriticalSection call. */
       lock = (const uint8_t *) memmem ((const char *) use_cwd, 80,
                                        "\x48\x8d\x0d", 3);
+      if (lock)
+	{
+	  /* A recent Windows 11 Preview calls `lea rel(rip),%rcx' then
+	     a `mov` and a `movups` instruction, and only then
+	     `callq RtlEnterCriticalSection'.
+	     */
+	  if (memmem (lock + 7, 8, "\x4c\x89\x78\x10\x0f\x11\x40\xc8", 8))
+	    {
+	      call_rtl_offset = 15;
+	    }
+	}
+
       if (!lock)
 	{
 	  /* Windows 8.1 Preview calls `lea rel(rip),%r12' then some unrelated

From 58a13d8581f3f0fe6f8357331d4ec3f6cf1f1c57 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Mon, 18 Aug 2025 06:18:53 +0000
Subject: [PATCH 62/84] ci: bump actions/checkout from 3 to 5

Bumps [actions/checkout](https://github.com/actions/checkout) from 3 to 5.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v3...v5)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-version: '5'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Original-patch-by: dependabot[bot] <support@github.com>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 .github/workflows/cygwin.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/cygwin.yml b/.github/workflows/cygwin.yml
index 877f54cdeb..40670cce8c 100644
--- a/.github/workflows/cygwin.yml
+++ b/.github/workflows/cygwin.yml
@@ -24,7 +24,7 @@ jobs:
       HAS_SSH_KEY: ${{ secrets.SSH_KEY != '' }}
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v5
 
     # install build tools
     - name: Install build tools
@@ -111,7 +111,7 @@ jobs:
       run: |
         icacls . /inheritance:r
         icacls . /grant Administrators:F
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v5
 
     # install cygwin and build tools
     - name: Install Cygwin

From 82b5b1093651f7a4e8eb101f20a34affe7c83309 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Fri, 10 Oct 2025 09:08:59 +0200
Subject: [PATCH 63/84] fixup! CI: add a GHA for doing a basic build test

Bumps [actions/download-artifact](https://github.com/actions/download-artifact) from 4 to 5.
- [Release notes](https://github.com/actions/download-artifact/releases)
- [Commits](actions/download-artifact@v4...v5)

---
updated-dependencies:
- dependency-name: actions/download-artifact
  dependency-version: '5'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Original-patch-by: dependabot[bot] <support@github.com>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 .github/workflows/build.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
index 5eeac8e9b8..a28b1c81cd 100644
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -81,7 +81,7 @@ jobs:
           msys2 -c 'pacman --noconfirm -Suu'
 
       - name: Download msys2-runtime artifact
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v5
         with:
           name: install
           path: ${{ steps.msys2.outputs.msys2-location }}

From 48af390e48c01c2c9f09df2d8c97f73c750d3f68 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Mon, 18 Aug 2025 06:18:53 +0000
Subject: [PATCH 64/84] fixup! CI: add a GHA for doing a basic build test

Bumps [actions/checkout](https://github.com/actions/checkout) from 4 to 5.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4...v5)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-version: '5'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Original-patch-by: dependabot[bot] <support@github.com>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 .github/workflows/build.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
index a28b1c81cd..c680f97313 100644
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -11,7 +11,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: setup-msys2
         uses: msys2/setup-msys2@v2

From cb48c880ca4517d70f334a61c9ddf286c738a86f Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Fri, 20 Feb 2015 11:54:47 +0000
Subject: [PATCH 65/84] Mention the extremely useful small_printf() function

It came in real handy while debugging an issue that strace 'fixed'.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/DevDocs/how-to-debug-cygwin.txt | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/winsup/cygwin/DevDocs/how-to-debug-cygwin.txt b/winsup/cygwin/DevDocs/how-to-debug-cygwin.txt
index 61e91c88d5..953d375864 100644
--- a/winsup/cygwin/DevDocs/how-to-debug-cygwin.txt
+++ b/winsup/cygwin/DevDocs/how-to-debug-cygwin.txt
@@ -126,3 +126,9 @@ set CYGWIN_DEBUG=cat.exe:gdb.exe
    program will crash, probably in small_printf.  At that point, a 'bt'
    command should show you the offending call to strace_printf with the
    improper format string.
+
+9. Debug output without strace
+
+   If you cannot use gdb, or if the program behaves differently using strace
+   for whatever reason, you can still use the small_printf() function to
+   output debugging messages directly to stderr.

From c6e68dc5bbca2e3bb99215338573ddc4983cc664 Mon Sep 17 00:00:00 2001
From: Karsten Blees <blees@dcon.de>
Date: Wed, 20 May 2015 16:32:52 +0200
Subject: [PATCH 66/84] Allow native symlinks to non-existing targets in
 'nativestrict' mode

Windows native symlinks must match the type of their target (file or
directory), otherwise native Windows tools will fail. Creating symlinks in
'nativestrict' mode currently requires the target to exist in order to
check its type.

However, the target of a symlink can change at any time after the symlink
has been created. Thus users of native symlinks must be prepared to deal
with type mismatches anyway. Checking the target type at symlink creation
time is not a good reason to violate the symlink() API specification.

In 'nativestrict' mode, always create native symlinks. Choose the symlink
type according to the target if it exists. Otherwise check the target path
for a trailing '/' as hint to create a directory symlink.

This allows callers to explicitly specify the expected target type, e.g.:

  $ ln -s test/ link-to-test
  $ mkdir test

Signed-off-by: Karsten Blees <blees@dcon.de>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/path.cc | 42 +++++++++++++++++++++++++++++++++---------
 1 file changed, 33 insertions(+), 9 deletions(-)

diff --git a/winsup/cygwin/path.cc b/winsup/cygwin/path.cc
index 8aff97acbe..3b9cba9fe9 100644
--- a/winsup/cygwin/path.cc
+++ b/winsup/cygwin/path.cc
@@ -1839,7 +1839,7 @@ symlink_native (const char *oldpath, path_conv &win32_newpath)
   path_conv win32_oldpath;
   PUNICODE_STRING final_oldpath, final_newpath;
   UNICODE_STRING final_oldpath_buf;
-  DWORD flags;
+  DWORD flags = 0;
 
   if (resolve_symlink_target (oldpath, win32_newpath, win32_oldpath))
     final_oldpath = win32_oldpath.get_nt_native_path ();
@@ -1901,14 +1901,39 @@ symlink_native (const char *oldpath, path_conv &win32_newpath)
 	    wcpcpy (e_old, c_old);
 	}
     }
-  /* If the symlink target doesn't exist, don't create native symlink.
-     Otherwise the directory flag in the symlink is potentially wrong
-     when the target comes into existence, and native tools will fail.
-     This is so screwball. This is no problem on AFS, fortunately. */
-  if (!win32_oldpath.exists () && !win32_oldpath.fs_is_afs ())
+
+  /* The directory flag in the symlink must match the target type,
+     otherwise native tools will fail (fortunately this is no problem
+     on AFS). Do our best to guess the symlink type correctly. */
+  if (win32_oldpath.exists () || win32_oldpath.fs_is_afs ())
     {
-      SetLastError (ERROR_FILE_NOT_FOUND);
-      return -1;
+      /* If the target exists (or on AFS), check the target type. Note
+	 that this may still be wrong if the target is changed after
+	 creating the symlink (e.g. in bulk operations such as rsync,
+	 unpacking archives or VCS checkouts). */
+      if (win32_oldpath.isdir ())
+        flags |= SYMBOLIC_LINK_FLAG_DIRECTORY;
+    }
+  else
+    {
+      if (allow_winsymlinks == WSYM_nativestrict)
+	{
+	  /* In nativestrict mode, if the target does not exist, use
+	     trailing '/' in the target path as hint to create a
+	     directory symlink. */
+	  ssize_t len = strlen(oldpath);
+	  if (len && isdirsep(oldpath[len - 1]))
+            flags |= SYMBOLIC_LINK_FLAG_DIRECTORY;
+	}
+      else
+	{
+	 /* In native mode, if the target does not exist, fall back
+	    to creating a Cygwin symlink file (or in case of MSys:
+	    try to copy the (non-existing) target, which will of
+	    course fail). */
+	  SetLastError (ERROR_FILE_NOT_FOUND);
+	  return -1;
+	}
     }
   /* Don't allow native symlinks to Cygwin special files.  However, the
      caller shoud know because this case shouldn't be covered by the
@@ -1937,7 +1962,6 @@ symlink_native (const char *oldpath, path_conv &win32_newpath)
 	final_oldpath->Buffer[1] = L'\\';
     }
   /* Try to create native symlink. */
-  flags = win32_oldpath.isdir () ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;
   if (wincap.has_unprivileged_createsymlink ())
     flags |= SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;
   if (!CreateSymbolicLinkW (final_newpath->Buffer, final_oldpath->Buffer,

From 2a9d34f306dd4562bbbd32b10870412ee8126e5d Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Fri, 20 Feb 2015 13:56:22 +0000
Subject: [PATCH 67/84] WIP Handle 8-bit characters under LOCALE=C

TODO!!! Verify that this is still needed, as it seems to be no longer
necessary to pass Git's test suite because the official MSYS2 runtime
lacks this patch yet is sufficient to let Git's test suite succeed.

Even when the character set is specified as ASCII, we should handle data
outside the 7-bit range gracefully by simply copying it, even if it is
technically no longer ASCII.

This fixes several of Git for Windows' tests, e.g. t7400.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/strfuncs.cc | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/winsup/cygwin/strfuncs.cc b/winsup/cygwin/strfuncs.cc
index eb6576051d..4542003cfc 100644
--- a/winsup/cygwin/strfuncs.cc
+++ b/winsup/cygwin/strfuncs.cc
@@ -1189,7 +1189,11 @@ _sys_mbstowcs (mbtowc_p f_mbtowc, wchar_t *dst, size_t dlen, const char *src,
 	    {
 	      bytes = 1;
 	      if (dst)
+#ifdef STRICTLY_7BIT_ASCII
 		*ptr = L'\xf000' | *pmbs;
+#else
+		*ptr = *pmbs;
+#endif
 	    }
 	  memset (&ps, 0, sizeof ps);
 	}

From 7721d4267a9478f789f2235e8761a29421663fc3 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Fri, 18 Dec 2015 20:19:57 +0100
Subject: [PATCH 68/84] Make paths' WCS->MBS conversion explicit

	* dcrt0.cc (dll_crt0_1), dtable.cc (handle_to_fn), environ.cc
	(environ_init, getwinenveq, build_env), external.cc
	(fillout_pinfo), fhandler_disk_file.cc (__DIR_mounts::eval_ino,
	fhandler_disk_file::readdir_helper), fhandler_netdrive.cc
	(fhandler_netdrive::readdir), fhandler_process.cc
	(format_process_winexename, format_process_maps,
	format_process_stat, format_process_status), fhandler_procsys.cc
	(fill_filebuf, fhandler_procsys::readdir), mount.cc
	(fs_info::update, mount_info::create_root_entry,
	mount_info::conv_to_posix_path, mount_info::from_fstab_line),
	nlsfuncs.cc (internal_setlocale), path.cc (path_conv::check,
	sysmlink_info::check_shortcut, symlink_info::check_sysfile,
	symlink_info::check_reparse_point,
	symlink_info::check_nfs_symlink, cygwin_conv_path,
	cygwin_conv_path_list, cwdstuff::get_error_desc, cwdstuff::get),
	strfuncs.cc (sys_wcstombs_no_path, sys_wcstombs_alloc_no_path),
	uinfo.cc (ontherange, fetch_from_path, cygheap_pwdgrp::get_home,
	cygheap_pwdgrp::get_shell, cygheap_pwdgrp::get_gecos), wchar.h
	(sys_wcstombs_no_path, sys_wcstombs_alloc_no_path): Convert call
	sites of the sys_wcstombs*() family to specify explicitly when the
	parameter refers to a path or file name, to avoid future
	misconversions.

Detailed explanation:

The sys_wcstombs() function contains special handling for paths/file
names, to work around file name restriction on Windows that are
unexpected in the POSIX context of Cygwin.

We actually do not want that special handling for WCS strings that
do *not* refer to paths or file names.

Neither do we want to convert those special file names unless they come
from inside Cygwin: if the source of the string value is the Windows API,
we *know* it cannot be such a special file name because Windows itself
would not be able to handle it in the way Cygwin does.

So let's switch the previous sys_wcstombs()/sys_wcstombs_no_path() (and
the *_alloc* variant) around to sys_wcstombs_path()/sys_wcstombs(). We do
this for several reasons:

- whenever a call site wants to convert a WCS representation of a path or
  file name to an MBS one, it should be made very clear that we *want* the
  special file name conversion to happen.

- it is shorter to read and write.

- future calls to sys_wcstombs() will not incur unwanted conversion by
  accident (it is easy for unsuspecting programmers to assume that the
  function name "sys_wcstombs()" refers to a regular text conversion that
  has nothing to do with paths or filenames).

By keeping the name sys_wcstombs() (and not switching to
sys_wcstombs_path()), the following call sites are implicitly changed to
*exclude* the special path/file name conversion:

cygheap.h (get_drive):
	Cannot contain special characters

external.cc (cygwin_internal):
	Refers to user/domain names, not paths

fhandler_clipboard.cc (fhandler_dev_clipboard::read):
	Is not a path or file name but characters from the Windows
	clipboard

fhandler_console.cc: (dev_console::con_to_str):
	Is not a path or file name but characters from the console

fhandler_registry.cc (encode_regname):
	Is a registry key, not a path or filename

fhandler_registry.cc (multi_wcstombs):
	All call sites pass registry values, not paths or filenames

fhandler_registry.cc (fstat):
	Is a registry value, not a path or filename

fhandler_registry.cc (fill_filebuf):
	Is a registry value, not a path or filename

net.cc (get_ipv4fromreg):
	Is a registry value, not a path or filename

net.cc (get_friendlyname):
	Is a device name, not a path or filename

netdb.cc (open_system_file):
	Is from outside Cygwin

smallprint.cc (__small_vsprintf):
	Is a free text, not a path or filename

strfuncs.cc (strlwr):
	Should preserve the characters from the private page if there
	are any

strfuncs.cc (strupr):
	Should preserve the characters from the private page if there
	are any

uinfo.cc (cygheap_user::init):
	Refers to a user name, not a path or filename

uinfo.cc (pwdgrp::fetch_account_from_windows):
	Refers to value from outside Cygwin

By keeping the function name sys_wcstombs_alloc() (and not changing it to
sys_wcstombs_alloc_path()), the following call sites are implicitly
changed to *exclude* the special path/file name conversion:

ldap.cc (cyg_ldap::remap_uid):
	Refers to a user name, not a path or filename

ldap.cc (cyg_ldap::remap_gid):
	Refers to a group name, not a path or filename

pinfo.cc (_pinfo::cmdline):
	Refers to a command line from Windows, outside Cygwin

uinfo.cc (cygheap_user::env_logsrv):
	Is a server name, not a path or filename

uinfo.cc (cygheap_user::env_domain):
	Refers to the user/domain name, not a path or filename

uinfo.cc (cygheap_user::env_userprofile):
	Refers to Windows' idea of a path, outside Cygwin

uinfo.cc (cygheap_user::env_systemroot):
	Refers to Windows' idea of a path, outside Cygwin

uinfo.cc (fetch_from_description):
	Refers to values from outside of Cygwin

uinfo.cc (cygheap_pwdgrp::get_gecos):
	Refers to user/domain name and email address, not path nor filename

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 winsup/cygwin/dcrt0.cc               |  4 ++--
 winsup/cygwin/dtable.cc              |  2 +-
 winsup/cygwin/environ.cc             |  8 ++++----
 winsup/cygwin/external.cc            |  2 +-
 winsup/cygwin/fhandler/disk_file.cc  |  4 ++--
 winsup/cygwin/fhandler/netdrive.cc   |  2 +-
 winsup/cygwin/fhandler/process.cc    | 11 ++++++-----
 winsup/cygwin/fhandler/procsys.cc    | 11 ++++++-----
 winsup/cygwin/local_includes/wchar.h | 16 +++++++--------
 winsup/cygwin/mount.cc               | 10 +++++-----
 winsup/cygwin/nlsfuncs.cc            |  2 +-
 winsup/cygwin/path.cc                | 29 ++++++++++++++--------------
 winsup/cygwin/uinfo.cc               | 20 +++++++++----------
 13 files changed, 62 insertions(+), 59 deletions(-)

diff --git a/winsup/cygwin/dcrt0.cc b/winsup/cygwin/dcrt0.cc
index f4c09befd6..57d4b8842c 100644
--- a/winsup/cygwin/dcrt0.cc
+++ b/winsup/cygwin/dcrt0.cc
@@ -900,9 +900,9 @@ dll_crt0_1 (void *)
   if (!__argc)
     {
       PWCHAR wline = GetCommandLineW ();
-      size_t size = sys_wcstombs_no_path (NULL, 0, wline) + 1;
+      size_t size = sys_wcstombs (NULL, 0, wline) + 1;
       char *line = (char *) alloca (size);
-      sys_wcstombs_no_path (line, size, wline);
+      sys_wcstombs (line, size, wline);
 
       /* Scan the command line and build argv.  Expand wildcards if not
 	 called from another cygwin process. */
diff --git a/winsup/cygwin/dtable.cc b/winsup/cygwin/dtable.cc
index 7303f7eacc..b99c80bf13 100644
--- a/winsup/cygwin/dtable.cc
+++ b/winsup/cygwin/dtable.cc
@@ -1021,7 +1021,7 @@ handle_to_fn (HANDLE h, char *posix_fn)
       if (wcsncasecmp (w32, DEVICE_PREFIX, DEVICE_PREFIX_LEN) != 0
 	  || !QueryDosDeviceW (NULL, fnbuf, sizeof (fnbuf) / sizeof (WCHAR)))
 	{
-	  sys_wcstombs (posix_fn, NT_MAX_PATH, w32, w32len);
+	  sys_wcstombs_path (posix_fn, NT_MAX_PATH, w32, w32len);
 	  return false;
 	}
 
diff --git a/winsup/cygwin/environ.cc b/winsup/cygwin/environ.cc
index d4cedcbdfe..7077595085 100644
--- a/winsup/cygwin/environ.cc
+++ b/winsup/cygwin/environ.cc
@@ -873,7 +873,7 @@ win32env_to_cygenv (PWCHAR rawenv, bool posify)
      eventually want to use them).  */
   for (i = 0, w = rawenv; *w != L'\0'; w = wcschr (w, L'\0') + 1, i++)
     {
-      sys_wcstombs_alloc_no_path (&newp, HEAP_NOTHEAP, w);
+      sys_wcstombs_alloc (&newp, HEAP_NOTHEAP, w);
       if (i >= envc)
         envp = (char **) realloc (envp, (4 + (envc += 100)) * sizeof (char *));
       envp[i] = newp;
@@ -919,7 +919,7 @@ getwinenveq (const char *name, size_t namelen, int x)
   int totlen = GetEnvironmentVariableW (name0, valbuf, 32768);
   if (totlen > 0)
     {
-      totlen = sys_wcstombs_no_path (NULL, 0, valbuf) + 1;
+      totlen = sys_wcstombs (NULL, 0, valbuf) + 1;
       if (x == HEAP_1_STR)
 	totlen += namelen;
       else
@@ -927,7 +927,7 @@ getwinenveq (const char *name, size_t namelen, int x)
       char *p = (char *) cmalloc_abort ((cygheap_types) x, totlen);
       if (namelen)
 	strcpy (p, name);
-      sys_wcstombs_no_path (p + namelen, totlen, valbuf);
+      sys_wcstombs (p + namelen, totlen, valbuf);
       debug_printf ("using value from GetEnvironmentVariable for '%W'", name0);
       return p;
     }
@@ -1084,7 +1084,7 @@ build_env (const char * const *envp, PWCHAR &envblock, int &envc,
 	  for (winnum = 0, var = cwinenv;
 	       *var;
 	       ++winnum, var = wcschr (var, L'\0') + 1)
-	    sys_wcstombs_alloc_no_path (&winenv[winnum], HEAP_NOTHEAP, var);
+	    sys_wcstombs_alloc (&winenv[winnum], HEAP_NOTHEAP, var);
 	}
       DestroyEnvironmentBlock (cwinenv);
       /* Eliminate variables which are already available in envp, as well as
diff --git a/winsup/cygwin/external.cc b/winsup/cygwin/external.cc
index 50a5af24f9..945b9b88fc 100644
--- a/winsup/cygwin/external.cc
+++ b/winsup/cygwin/external.cc
@@ -92,7 +92,7 @@ fillout_pinfo (pid_t pid, int winpid)
 	  ep.rusage_self = p->rusage_self;
 	  ep.rusage_children = p->rusage_children;
 	  ep.progname[0] = '\0';
-	  sys_wcstombs(ep.progname, MAX_PATH, p->progname);
+	  sys_wcstombs_path (ep.progname, MAX_PATH, p->progname);
 	  ep.strace_mask = 0;
 	  ep.version = EXTERNAL_PINFO_VERSION;
 
diff --git a/winsup/cygwin/fhandler/disk_file.cc b/winsup/cygwin/fhandler/disk_file.cc
index d54d3747ea..caf69f808a 100644
--- a/winsup/cygwin/fhandler/disk_file.cc
+++ b/winsup/cygwin/fhandler/disk_file.cc
@@ -2403,7 +2403,7 @@ fhandler_disk_file::readdir_helper (DIR *dir, dirent *de, DWORD w32_err,
 	  char *p = stpcpy (file, pc.get_posix ());
 	  if (p[-1] != '/')
 	    *p++ = '/';
-	  sys_wcstombs (p, NT_MAX_PATH - (p - file),
+	  sys_wcstombs_path (p, NT_MAX_PATH - (p - file),
 			fname->Buffer, fname->Length / sizeof (WCHAR));
 	  path_conv fpath (file, PC_SYM_NOFOLLOW);
 	  if (fpath.issymlink ())
@@ -2424,7 +2424,7 @@ fhandler_disk_file::readdir_helper (DIR *dir, dirent *de, DWORD w32_err,
 	}
     }
 
-  sys_wcstombs (de->d_name, NAME_MAX + 1, fname->Buffer,
+  sys_wcstombs_path (de->d_name, NAME_MAX + 1, fname->Buffer,
 		fname->Length / sizeof (WCHAR));
 
   /* Don't try to optimize relative to dir->__d_position.  On several
diff --git a/winsup/cygwin/fhandler/netdrive.cc b/winsup/cygwin/fhandler/netdrive.cc
index 426542fe21..4f732b6d95 100644
--- a/winsup/cygwin/fhandler/netdrive.cc
+++ b/winsup/cygwin/fhandler/netdrive.cc
@@ -648,7 +648,7 @@ fhandler_netdrive::readdir (DIR *dir, dirent *de)
       goto out;
     }
 
-  sys_wcstombs (de->d_name, sizeof de->d_name, DIR_cache[dir->__d_position]);
+  sys_wcstombs_path (de->d_name, sizeof de->d_name, DIR_cache[dir->__d_position]);
   if (strlen (dir->__d_dirname) == 2)
     de->d_ino = hash_path_name (get_ino (), de->d_name);
   else
diff --git a/winsup/cygwin/fhandler/process.cc b/winsup/cygwin/fhandler/process.cc
index e00cae58d7..1eacee3fa4 100644
--- a/winsup/cygwin/fhandler/process.cc
+++ b/winsup/cygwin/fhandler/process.cc
@@ -578,10 +578,10 @@ static off_t
 format_process_winexename (void *data, char *&destbuf)
 {
   _pinfo *p = (_pinfo *) data;
-  size_t len = sys_wcstombs (NULL, 0, p->progname);
+  size_t len = sys_wcstombs_path (NULL, 0, p->progname);
   destbuf = (char *) crealloc_abort (destbuf, len + 1);
   /* With trailing \0 for backward compat reasons. */
-  sys_wcstombs (destbuf, len + 1, p->progname);
+  sys_wcstombs_path (destbuf, len + 1, p->progname);
   return len;
 }
 
@@ -1082,7 +1082,7 @@ format_process_maps (void *data, char *&destbuf)
 		      drive_maps.fixup_if_match (msi->SectionFileName.Buffer);
 		  if (mount_table->conv_to_posix_path (dosname,
 						       posix_modname, 0))
-		    sys_wcstombs (posix_modname, NT_MAX_PATH, dosname);
+		    sys_wcstombs_path (posix_modname, NT_MAX_PATH, dosname);
 		  stat (posix_modname, &st);
 		}
 	      else if (!threads.fill_if_match (cur.abase, mb.Type,
@@ -1138,7 +1138,7 @@ format_process_stat (void *data, char *&destbuf)
   else
     {
       PWCHAR last_slash = wcsrchr (p->progname, L'\\');
-      sys_wcstombs (cmd, NAME_MAX + 1,
+      sys_wcstombs_path (cmd, NAME_MAX + 1,
 		    last_slash ? last_slash + 1 : p->progname);
       int len = strlen (cmd);
       if (len > 4)
@@ -1266,7 +1266,8 @@ format_process_status (void *data, char *&destbuf)
   bool fetch_siginfo = false;
 
   PWCHAR last_slash = wcsrchr (p->progname, L'\\');
-  sys_wcstombs (cmd, NAME_MAX + 1, last_slash ? last_slash + 1 : p->progname);
+  sys_wcstombs_path (cmd, NAME_MAX + 1,
+		  last_slash ? last_slash + 1 : p->progname);
   int len = strlen (cmd);
   if (len > 4)
     {
diff --git a/winsup/cygwin/fhandler/procsys.cc b/winsup/cygwin/fhandler/procsys.cc
index aa021e89c7..832434bb82 100644
--- a/winsup/cygwin/fhandler/procsys.cc
+++ b/winsup/cygwin/fhandler/procsys.cc
@@ -236,10 +236,11 @@ fhandler_procsys::fill_filebuf ()
   NtClose (h);
   if (!NT_SUCCESS (status))
     goto unreadable;
-  len = sys_wcstombs (NULL, 0, target.Buffer, target.Length / sizeof (WCHAR));
+  len = sys_wcstombs_path (NULL, 0,
+		  target.Buffer, target.Length / sizeof (WCHAR));
   filebuf = (char *) crealloc_abort (filebuf, procsys_len + len + 1);
-  sys_wcstombs (fnamep = stpcpy (filebuf, procsys), len + 1, target.Buffer,
-		target.Length / sizeof (WCHAR));
+  sys_wcstombs_path (fnamep = stpcpy (filebuf, procsys), len + 1,
+		  target.Buffer, target.Length / sizeof (WCHAR));
   while ((fnamep = strchr (fnamep, '\\')))
     *fnamep = '/';
   return true;
@@ -377,8 +378,8 @@ fhandler_procsys::readdir (DIR *dir, dirent *de)
 	res = ENMFILE;
       else
 	{
-	  sys_wcstombs (de->d_name, NAME_MAX + 1, dbi->ObjectName.Buffer,
-			dbi->ObjectName.Length / sizeof (WCHAR));
+	  sys_wcstombs_path (de->d_name, NAME_MAX + 1, dbi->ObjectName.Buffer,
+			     dbi->ObjectName.Length / sizeof (WCHAR));
 	  de->d_ino = hash_path_name (get_ino (), de->d_name);
 	  if (RtlEqualUnicodeString (&dbi->ObjectTypeName, &ro_u_natdir, FALSE))
 	    de->d_type = DT_DIR;
diff --git a/winsup/cygwin/local_includes/wchar.h b/winsup/cygwin/local_includes/wchar.h
index 606559a6ab..c6ec5d8758 100644
--- a/winsup/cygwin/local_includes/wchar.h
+++ b/winsup/cygwin/local_includes/wchar.h
@@ -173,29 +173,29 @@ extern size_t _sys_wcstombs_alloc (char **dst_p, int type, const wchar_t *src,
 				   size_t nwc, bool is_path);
 
 static inline size_t
-sys_wcstombs (char *dst, size_t len, const wchar_t * src,
-	      size_t nwc = (size_t) -1)
+sys_wcstombs_path (char *dst, size_t len, const wchar_t * src,
+		   size_t nwc = (size_t) -1)
 {
   return _sys_wcstombs (dst, len, src, nwc, true);
 }
 
 static inline size_t
-sys_wcstombs_no_path (char *dst, size_t len, const wchar_t * src,
-		      size_t nwc = (size_t) -1)
+sys_wcstombs (char *dst, size_t len, const wchar_t * src,
+	      size_t nwc = (size_t) -1)
 {
   return _sys_wcstombs (dst, len, src, nwc, false);
 }
 
 static inline size_t
-sys_wcstombs_alloc (char **dst_p, int type, const wchar_t *src,
-		    size_t nwc = (size_t) -1)
+sys_wcstombs_alloc_path (char **dst_p, int type, const wchar_t *src,
+			 size_t nwc = (size_t) -1)
 {
   return _sys_wcstombs_alloc (dst_p, type, src, nwc, true);
 }
 
 static inline size_t
-sys_wcstombs_alloc_no_path (char **dst_p, int type, const wchar_t *src,
-			    size_t nwc = (size_t) -1)
+sys_wcstombs_alloc (char **dst_p, int type, const wchar_t *src,
+		    size_t nwc = (size_t) -1)
 {
   return _sys_wcstombs_alloc (dst_p, type, src, nwc, false);
 }
diff --git a/winsup/cygwin/mount.cc b/winsup/cygwin/mount.cc
index 1cfee5c415..61f06d06c2 100644
--- a/winsup/cygwin/mount.cc
+++ b/winsup/cygwin/mount.cc
@@ -508,7 +508,7 @@ fs_info::update (PUNICODE_STRING upath, HANDLE in_vol)
     {
       /* The filesystem name is only used in fillout_mntent and only if
 	 the filesystem isn't one of the well-known filesystems anyway. */
-      sys_wcstombs (fsn, sizeof fsn, ffai_buf.ffai.FileSystemName,
+      sys_wcstombs_path (fsn, sizeof fsn, ffai_buf.ffai.FileSystemName,
 		    ffai_buf.ffai.FileSystemNameLength / sizeof (WCHAR));
       strlwr (fsn);
     }
@@ -549,7 +549,7 @@ mount_info::create_root_entry (const PWCHAR root)
  /* Create a default root dir derived from the location of the Cygwin DLL.
     The entry is immutable, unless the "override" option is given in /etc/fstab. */
   char native_root[PATH_MAX];
-  sys_wcstombs (native_root, PATH_MAX, root);
+  sys_wcstombs_path (native_root, PATH_MAX, root);
   assert (*native_root != '\0');
   if (add_item (native_root, "/",
 		MOUNT_SYSTEM | MOUNT_IMMUTABLE | MOUNT_AUTOMATIC)
@@ -942,7 +942,7 @@ mount_info::conv_to_posix_path (PWCHAR src_path, char *posix_path,
     }
   tmp_pathbuf tp;
   char *buf = tp.c_get ();
-  sys_wcstombs (buf, NT_MAX_PATH, src_path);
+  sys_wcstombs_path (buf, NT_MAX_PATH, src_path);
   int ret = conv_to_posix_path (buf, posix_path, ccp_flags);
   if (changed)
     src_path[0] = L'C';
@@ -1263,7 +1263,7 @@ mount_info::from_fstab_line (char *line, bool user)
 	{
 	  tmp_pathbuf tp;
 	  char *mb_tmp = tp.c_get ();
-	  sys_wcstombs (mb_tmp, PATH_MAX, tmp);
+	  sys_wcstombs_path (mb_tmp, PATH_MAX, tmp);
 
 	  mount_flags |= MOUNT_USER_TEMP;
 	  int res = mount_table->add_item (mb_tmp, posix_path, mount_flags);
@@ -1752,7 +1752,7 @@ mount_info::cygdrive_getmntent ()
   if (wide_path)
     {
       win32_path = tp.c_get ();
-      sys_wcstombs (win32_path, NT_MAX_PATH, wide_path);
+      sys_wcstombs_path (win32_path, NT_MAX_PATH, wide_path);
       posix_path = tp.c_get ();
       cygdrive_posix_path (win32_path, posix_path, 0);
       return fillout_mntent (win32_path, posix_path, cygdrive_flags);
diff --git a/winsup/cygwin/nlsfuncs.cc b/winsup/cygwin/nlsfuncs.cc
index f57465a4f2..57af967c1a 100644
--- a/winsup/cygwin/nlsfuncs.cc
+++ b/winsup/cygwin/nlsfuncs.cc
@@ -1776,7 +1776,7 @@ internal_setlocale ()
   if (w_path)
     {
       char *c_path = tp.c_get ();
-      sys_wcstombs (c_path, 32768, w_path);
+      sys_wcstombs_path (c_path, 32768, w_path);
       setenv ("PATH", c_path, 1);
     }
 }
diff --git a/winsup/cygwin/path.cc b/winsup/cygwin/path.cc
index 8aff97acbe..2c57e3f128 100644
--- a/winsup/cygwin/path.cc
+++ b/winsup/cygwin/path.cc
@@ -652,7 +652,8 @@ path_conv::check (const UNICODE_STRING *src, unsigned opt,
   char *path = tp.c_get ();
 
   user_shared->warned_msdos = true;
-  sys_wcstombs (path, NT_MAX_PATH, src->Buffer, src->Length / sizeof (WCHAR));
+  sys_wcstombs_path (path, NT_MAX_PATH,
+		  src->Buffer, src->Length / sizeof (WCHAR));
   path_conv::check (path, opt, suffixes);
 }
 
@@ -2435,7 +2436,7 @@ symlink_info::check_shortcut (HANDLE h)
       if (*(PWCHAR) cp == 0xfeff)	/* BOM */
 	{
 	  char *tmpbuf = tp.c_get ();
-	  if (sys_wcstombs (tmpbuf, NT_MAX_PATH, (PWCHAR) (cp + 2))
+	  if (sys_wcstombs_path (tmpbuf, NT_MAX_PATH, (PWCHAR) (cp + 2))
 	      > SYMLINK_MAX)
 	    return 0;
 	  res = posixify (tmpbuf);
@@ -2516,7 +2517,7 @@ symlink_info::check_sysfile (HANDLE h)
 	  else
 	    srcbuf += 2;
 	  char *tmpbuf = tp.c_get ();
-	  if (sys_wcstombs (tmpbuf, NT_MAX_PATH, (PWCHAR) srcbuf)
+	  if (sys_wcstombs_path (tmpbuf, NT_MAX_PATH, (PWCHAR) srcbuf)
 	      > SYMLINK_MAX)
 	    debug_printf ("symlink string too long");
 	  else
@@ -2784,8 +2785,8 @@ symlink_info::check_reparse_point (HANDLE h, bool remote)
   path_flags (path_flags () | ret);
   if (ret & PATH_SYMLINK)
     {
-      sys_wcstombs (srcbuf, SYMLINK_MAX + 7, symbuf.Buffer,
-		    symbuf.Length / sizeof (WCHAR));
+      sys_wcstombs_path (srcbuf, SYMLINK_MAX + 7, symbuf.Buffer,
+		         symbuf.Length / sizeof (WCHAR));
       /* A symlink is never a directory. */
       fileattr (fileattr () & ~FILE_ATTRIBUTE_DIRECTORY);
       return posixify (srcbuf);
@@ -2819,7 +2820,7 @@ symlink_info::check_nfs_symlink (HANDLE h)
     {
       PWCHAR spath = (PWCHAR)
 		     (pffei->EaName + pffei->EaNameLength + 1);
-      res = sys_wcstombs (contents, SYMLINK_MAX + 1,
+      res = sys_wcstombs_path (contents, SYMLINK_MAX + 1,
 			  spath, pffei->EaValueLength);
       path_flags (path_flags () | PATH_SYMLINK);
     }
@@ -3950,7 +3951,7 @@ cygwin_conv_path (cygwin_conv_path_t what, const void *from, void *to,
 	      }
 	    PUNICODE_STRING up = p.get_nt_native_path ();
 	    buf = tp.c_get ();
-	    sys_wcstombs (buf, NT_MAX_PATH,
+	    sys_wcstombs_path (buf, NT_MAX_PATH,
 			  up->Buffer, up->Length / sizeof (WCHAR));
 	    /* Convert native path to standard DOS path. */
 	    if (!strncmp (buf, "\\??\\", 4))
@@ -3963,11 +3964,11 @@ cygwin_conv_path (cygwin_conv_path_t what, const void *from, void *to,
 	      {
 		/* Device name points to somewhere else in the NT namespace.
 		   Use GLOBALROOT prefix to convert to Win32 path. */
-		char *p = buf + sys_wcstombs (buf, NT_MAX_PATH,
+		char *p = buf + sys_wcstombs_path (buf, NT_MAX_PATH,
 					      ro_u_globalroot.Buffer,
 					      ro_u_globalroot.Length
 					      / sizeof (WCHAR));
-		sys_wcstombs (p, NT_MAX_PATH - (p - buf),
+		sys_wcstombs_path (p, NT_MAX_PATH - (p - buf),
 			      up->Buffer, up->Length / sizeof (WCHAR));
 	      }
 	    lsiz = strlen (buf) + 1;
@@ -4279,8 +4280,8 @@ cygwin_conv_path_list (cygwin_conv_path_t what, const void *from, void *to,
   switch (what & CCP_CONVTYPE_MASK)
     {
     case CCP_WIN_W_TO_POSIX:
-      if (!sys_wcstombs_alloc (&winp, HEAP_NOTHEAP, (const wchar_t *) from,
-			       (size_t) -1))
+      if (!sys_wcstombs_alloc_path (&winp, HEAP_NOTHEAP,
+			      (const wchar_t *) from, (size_t) -1))
 	return -1;
       what = (what & ~CCP_CONVTYPE_MASK) | CCP_WIN_A_TO_POSIX;
       from = (const void *) winp;
@@ -5054,9 +5055,9 @@ cwdstuff::get_error_desc () const
 void
 cwdstuff::reset_posix (wchar_t *w_cwd)
 {
-  size_t len = sys_wcstombs (NULL, (size_t) -1, w_cwd);
+  size_t len = sys_wcstombs_path (NULL, (size_t) -1, w_cwd);
   posix = (char *) crealloc_abort (posix, len + 1);
-  sys_wcstombs (posix, len + 1, w_cwd);
+  sys_wcstombs_path (posix, len + 1, w_cwd);
 }
 
 char *
@@ -5081,7 +5082,7 @@ cwdstuff::get (char *buf, int need_posix, int with_chroot, unsigned ulen)
   if (!need_posix)
     {
       tocopy = tp.c_get ();
-      sys_wcstombs (tocopy, NT_MAX_PATH, win32.Buffer,
+      sys_wcstombs_path (tocopy, NT_MAX_PATH, win32.Buffer,
 		    win32.Length / sizeof (WCHAR));
     }
   else
diff --git a/winsup/cygwin/uinfo.cc b/winsup/cygwin/uinfo.cc
index ffe71ee072..d2c829af48 100644
--- a/winsup/cygwin/uinfo.cc
+++ b/winsup/cygwin/uinfo.cc
@@ -385,12 +385,12 @@ cygheap_user::ontherange (homebodies what, struct passwd *pw)
 	    {
 	      if (ui->usri3_home_dir_drive && *ui->usri3_home_dir_drive)
 		{
-		  sys_wcstombs (homepath_env_buf, NT_MAX_PATH,
+		  sys_wcstombs_path (homepath_env_buf, NT_MAX_PATH,
 				ui->usri3_home_dir_drive);
 		  strcat (homepath_env_buf, "\\");
 		}
 	      else if (ui->usri3_home_dir && *ui->usri3_home_dir)
-		sys_wcstombs (homepath_env_buf, NT_MAX_PATH,
+		sys_wcstombs_path (homepath_env_buf, NT_MAX_PATH,
 			      ui->usri3_home_dir);
 	    }
 	  if (ui)
@@ -400,7 +400,7 @@ cygheap_user::ontherange (homebodies what, struct passwd *pw)
       if (!homepath_env_buf[0]
 	  && get_user_profile_directory (get_windows_id (win_id),
 					 profile, MAX_PATH))
-	sys_wcstombs (homepath_env_buf, NT_MAX_PATH, profile);
+	sys_wcstombs_path (homepath_env_buf, NT_MAX_PATH, profile);
       /* Last fallback: Cygwin root dir. */
       if (!homepath_env_buf[0])
 	cygwin_conv_path (CCP_POSIX_TO_WIN_A | CCP_ABSOLUTE,
@@ -919,7 +919,7 @@ fetch_from_path (cyg_ldap *pldap, PUSER_INFO_3 ui, cygpsid &sid, PCWSTR str,
 	}
     }
   *w = L'\0';
-  sys_wcstombs_alloc (&ret, HEAP_NOTHEAP, wpath);
+  sys_wcstombs_alloc_path (&ret, HEAP_NOTHEAP, wpath);
   return ret;
 }
 
@@ -987,7 +987,7 @@ cygheap_pwdgrp::get_home (cyg_ldap *pldap, cygpsid &sid, PCWSTR dom,
 	    {
 	      val = pldap->get_string_attribute (L"cygwinHome");
 	      if (val && *val)
-		sys_wcstombs_alloc (&home, HEAP_NOTHEAP, val);
+		sys_wcstombs_alloc_path (&home, HEAP_NOTHEAP, val);
 	    }
 	  break;
 	case NSS_SCHEME_UNIX:
@@ -995,7 +995,7 @@ cygheap_pwdgrp::get_home (cyg_ldap *pldap, cygpsid &sid, PCWSTR dom,
 	    {
 	      val = pldap->get_string_attribute (L"unixHomeDirectory");
 	      if (val && *val)
-		sys_wcstombs_alloc (&home, HEAP_NOTHEAP, val);
+		sys_wcstombs_alloc_path (&home, HEAP_NOTHEAP, val);
 	    }
 	  break;
 	case NSS_SCHEME_DESC:
@@ -1020,7 +1020,7 @@ cygheap_pwdgrp::get_home (cyg_ldap *pldap, cygpsid &sid, PCWSTR dom,
 		    home = (char *)
 			   cygwin_create_path (CCP_WIN_W_TO_POSIX, val);
 		  else
-		    sys_wcstombs_alloc (&home, HEAP_NOTHEAP, val);
+		    sys_wcstombs_alloc_path (&home, HEAP_NOTHEAP, val);
 		}
 	    }
 	  break;
@@ -1090,7 +1090,7 @@ cygheap_pwdgrp::get_shell (cyg_ldap *pldap, cygpsid &sid, PCWSTR dom,
 	    {
 	      val = pldap->get_string_attribute (L"cygwinShell");
 	      if (val && *val)
-		sys_wcstombs_alloc (&shell, HEAP_NOTHEAP, val);
+		sys_wcstombs_alloc_path (&shell, HEAP_NOTHEAP, val);
 	    }
 	  break;
 	case NSS_SCHEME_UNIX:
@@ -1098,7 +1098,7 @@ cygheap_pwdgrp::get_shell (cyg_ldap *pldap, cygpsid &sid, PCWSTR dom,
 	    {
 	      val = pldap->get_string_attribute (L"loginShell");
 	      if (val && *val)
-		sys_wcstombs_alloc (&shell, HEAP_NOTHEAP, val);
+		sys_wcstombs_alloc_path (&shell, HEAP_NOTHEAP, val);
 	    }
 	  break;
 	case NSS_SCHEME_DESC:
@@ -1123,7 +1123,7 @@ cygheap_pwdgrp::get_shell (cyg_ldap *pldap, cygpsid &sid, PCWSTR dom,
 		    shell = (char *)
 			    cygwin_create_path (CCP_WIN_W_TO_POSIX, val);
 		  else
-		    sys_wcstombs_alloc (&shell, HEAP_NOTHEAP, val);
+		    sys_wcstombs_alloc_path (&shell, HEAP_NOTHEAP, val);
 		}
 	    }
 	  break;

From 5c25e842e45c80f87ec018c4cbab4fe7191d78f0 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Thu, 21 Nov 2019 14:21:01 +0100
Subject: [PATCH 69/84] Use MB_CUR_MAX == 6 by default

Internally, Cygwin already uses __utf8_mbtowc(), even if it still claims
to use the "ASCII" charset.

But the `MB_CUR_MAX` value (which is not actually a constant, but
dependent on the current locale) was still 1, which broke the initial
`globify()` call while parsing the the command-line in `build_argv()`
for non-ASCII arguments.

This fixes https://github.com/git-for-windows/git/issues/2189

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 newlib/libc/locale/lctype.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/newlib/libc/locale/lctype.c b/newlib/libc/locale/lctype.c
index a07ab68124..3f118e98c7 100644
--- a/newlib/libc/locale/lctype.c
+++ b/newlib/libc/locale/lctype.c
@@ -25,7 +25,12 @@
 
 #define LCCTYPE_SIZE (sizeof(struct lc_ctype_T) / sizeof(char *))
 
+#ifdef __CYGWIN__
+/* Cygwin uses __utf8_mbtowc() by default, therefore mb_cur_max := 6 */
+static char	numone[] = { '\x06', '\0'};
+#else
 static char	numone[] = { '\1', '\0'};
+#endif
 
 const struct lc_ctype_T _C_ctype_locale = {
 	"ASCII",			/* codeset */

From df2f7356ed0fd3f8e3f845905aad885d450f5487 Mon Sep 17 00:00:00 2001
From: Richard Glidden <rglidden@brocksolutions.com>
Date: Thu, 24 Aug 2023 13:36:10 -0400
Subject: [PATCH 70/84] msys2-runtime: restore fast path for current user
 primary group

Commit a5bcfe616c7e removed an optimization that fetches the
default group from the current user token, as it is sometimes
not accurate such as when groups like the builtin
Administrators group is the primary group.

However, removing this optimization causes extremely poor
performance when connected to some Active Directory
environments.

Restored this optimization as the default behaviour, and
added a `group: db-accurate` option to `nsswitch.conf` that
can be used to disable the optimization in cases where
accurate group information is required.

This fixes https://github.com/git-for-windows/git/issues/4459

Signed-off-by: Richard Glidden <richard@glidden.org>
---
 winsup/cygwin/include/sys/cygwin.h     |  3 ++-
 winsup/cygwin/local_includes/cygheap.h |  1 +
 winsup/cygwin/uinfo.cc                 | 30 ++++++++++++++++++++------
 winsup/doc/ntsec.xml                   | 20 ++++++++++++++++-
 4 files changed, 46 insertions(+), 8 deletions(-)

diff --git a/winsup/cygwin/include/sys/cygwin.h b/winsup/cygwin/include/sys/cygwin.h
index f5c90fe96b..676d974138 100644
--- a/winsup/cygwin/include/sys/cygwin.h
+++ b/winsup/cygwin/include/sys/cygwin.h
@@ -213,7 +213,8 @@ enum
 enum
 {
   NSS_SRC_FILES = 1,
-  NSS_SRC_DB = 2
+  NSS_SRC_DB = 2,
+  NSS_SRC_DB_ACCURATE = 4
 };
 
 /* Enumeration source constants for CW_SETENT called from mkpasswd/mkgroup. */
diff --git a/winsup/cygwin/local_includes/cygheap.h b/winsup/cygwin/local_includes/cygheap.h
index d9e936c1e4..0b3fed297a 100644
--- a/winsup/cygwin/local_includes/cygheap.h
+++ b/winsup/cygwin/local_includes/cygheap.h
@@ -405,6 +405,7 @@ class cygheap_pwdgrp
   inline int  nss_pwd_src () const { return pwd_src; } /* CW_GETNSS_PWD_SRC */
   inline bool nss_grp_files () const { return !!(grp_src & NSS_SRC_FILES); }
   inline bool nss_grp_db () const { return !!(grp_src & NSS_SRC_DB); }
+  inline bool nss_grp_db_accurate () const { return !!(grp_src & NSS_SRC_DB_ACCURATE); }
   inline int  nss_grp_src () const { return grp_src; } /* CW_GETNSS_GRP_SRC */
   inline bool nss_cygserver_caching () const { return caching; }
   inline void nss_disable_cygserver_caching () { caching = false; }
diff --git a/winsup/cygwin/uinfo.cc b/winsup/cygwin/uinfo.cc
index ffe71ee072..cff9789b5d 100644
--- a/winsup/cygwin/uinfo.cc
+++ b/winsup/cygwin/uinfo.cc
@@ -637,6 +637,11 @@ cygheap_pwdgrp::nss_init_line (const char *line)
 		    *src |= NSS_SRC_DB;
 		    c += 2;
 		  }
+		else if (NSS_CMP ("db-accurate"))
+		  {
+		    *src |= NSS_SRC_DB | NSS_SRC_DB_ACCURATE;
+		    c += 11;
+		  }
 		else
 		  {
 		    c += strcspn (c, " \t");
@@ -1952,6 +1957,7 @@ pwdgrp::fetch_account_from_windows (fetch_user_arg_t &arg, cyg_ldap *pldap)
   gid_t gid = ILLEGAL_GID;
   bool is_domain_account = true;
   PCWSTR domain = NULL;
+  bool get_default_group_from_current_user_token = false;
   char *shell = NULL;
   char *home = NULL;
   char *gecos = NULL;
@@ -2466,9 +2472,19 @@ pwdgrp::fetch_account_from_windows (fetch_user_arg_t &arg, cyg_ldap *pldap)
 	    uid = posix_offset + sid_sub_auth_rid (sid);
 	  if (!is_group () && acc_type == SidTypeUser)
 	    {
-	      /* Default primary group.  Make the educated guess that the user
-		 is in group "Domain Users" or "None". */
-	      gid = posix_offset + DOMAIN_GROUP_RID_USERS;
+	      /* Default primary group.  If the sid is the current user, and
+		 we are not configured for accurate mode, fetch
+		 the default group from the current user token, otherwise make
+		 the educated guess that the user is in group "Domain Users"
+		 or "None". */
+	      if (!cygheap->pg.nss_grp_db_accurate() && sid == cygheap->user.sid ())
+		{
+		  get_default_group_from_current_user_token = true;
+		  gid = posix_offset
+			+ sid_sub_auth_rid (cygheap->user.groups.pgsid);
+		}
+	      else
+		gid = posix_offset + DOMAIN_GROUP_RID_USERS;
 	    }
 
 	  if (is_domain_account)
@@ -2476,9 +2492,11 @@ pwdgrp::fetch_account_from_windows (fetch_user_arg_t &arg, cyg_ldap *pldap)
 	      /* Skip this when creating group entries and for non-users. */
 	      if (is_group() || acc_type != SidTypeUser)
 		break;
-	      /* Fetch primary group from AD and overwrite the one we
-		 just guessed above. */
-	      if (cldap->fetch_ad_account (sid, false, domain))
+	      /* For the current user we got correctly cased username and
+		 the primary group via process token.  For any other user
+		 we fetch it from AD and overwrite it. */
+	      if (!get_default_group_from_current_user_token
+		  && cldap->fetch_ad_account (sid, false, domain))
 		{
 		  if ((val = cldap->get_account_name ()))
 		    wcscpy (name, val);
diff --git a/winsup/doc/ntsec.xml b/winsup/doc/ntsec.xml
index ae9270e6e3..768c75a5ec 100644
--- a/winsup/doc/ntsec.xml
+++ b/winsup/doc/ntsec.xml
@@ -930,7 +930,16 @@ The two lines starting with the keywords <literal>passwd:</literal> and
 information from.  <literal>files</literal> means, fetch the information
 from the corresponding file in the /etc directory.  <literal>db</literal>
 means, fetch the information from the Windows account databases, the SAM
-for local accounts, Active Directory for domain account.  Examples:
+for local accounts, Active Directory for domain account.  For the current
+user, the default group is obtained from the current user token to avoid
+additional lookups to the group database. <literal>db-accurate</literal>
+is only valid on <literal>group:</literal> line, and performs the same 
+lookups as the <literal>db</literal> option, but disables using the
+current user token to retrieve the default group as this optimization
+is not accurate in all cases.  For example, if you run a native process
+with the primary group set to the Administrators builtin group, the 
+<literal>db</literal> option will return a non-existent group as primary
+group. Examples:
 </para>
 
 <screen>
@@ -949,6 +958,15 @@ Read passwd entries only from /etc/passwd.
 Read group entries only from SAM/AD.
 </para>
 
+<screen>
+  group: db-accurate
+</screen>
+
+<para>
+Read group entries only from SAM/AD. Force the use of the group database
+for the current user.
+</para>
+
 <screen>
   group: files # db
 </screen>

From 30c80e0f79e692248e78745cf1fe32fdc7afb968 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EB=A7=88=EB=88=84=EC=97=98?= <nalla@hamal.uberspace.de>
Date: Mon, 9 Mar 2015 16:24:43 +0100
Subject: [PATCH 71/84] fixup! Add functionality for converting UNIX paths in
 arguments and environment variables to Windows form for native Win32
 applications.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When a non-ASCII character is at the beginning of a path, the current
conversion destroys the path. This fix will prevent this with an extra
check for non-ASCII UTF-8 characters.

Helped-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: 마누엘 <nalla@hamal.uberspace.de>
---
 winsup/cygwin/msys2_path_conv.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/winsup/cygwin/msys2_path_conv.cc b/winsup/cygwin/msys2_path_conv.cc
index 4c0cc82cf2..0dc086aae9 100644
--- a/winsup/cygwin/msys2_path_conv.cc
+++ b/winsup/cygwin/msys2_path_conv.cc
@@ -399,7 +399,7 @@ path_type find_path_start_and_type(const char** src, int recurse, const char* en
     }
     it = *src;
 
-    while (!isalnum(*it) && *it != '/' && *it != '\\' && *it != ':' && *it != '-' && *it != '.') {
+    while (!isalnum(*it) && !(0x80 & *it) && *it != '/' && *it != '\\' && *it != ':' && *it != '-' && *it != '.') {
         recurse = true;
         it = ++*src;
         if (it == end || *it == '\0') return NONE;

From a490c77a6bce1d328b66bbc978eac8f020d8c6b8 Mon Sep 17 00:00:00 2001
From: Mikael Larsson <95430516+chirpnot@users.noreply.github.com>
Date: Thu, 10 Mar 2022 17:26:42 +0000
Subject: [PATCH 72/84] Change the default base address for x86_64

This might break things, but it turns out several Windows libraries like
to be loaded at 0x180000000.

This causes a problem, because `msys-2.0.dll` loads at `0x180040000` and
expects `0x180000000-0x180040000` to be available. A problem arises when
Antiviruses (or other DLL hooking mechanisms) load a DLL whose preferred
load address is `0x180000000` and fits in size before `0x180010000`:

1. `msys-2.0.dll` loads and fills `0x180010000-0x180040000` assuming no
   shared console structure is going to be needed.

2. Another DLL loads and fills `0x180000000-0x18000xxxx`

3. `msys-2.0.dll` tries to load `0x180000000-0x180010000` but it's not
   available. It falls back to another address, but down the line
   something else fails.

This bug triggers when using subshells (e.g.: `git clone --recursive`).

The MSYS2 runtime should be able to work around the address conflict,
but the code is failing in some way or other...

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Mikael Larsson <95430516+chirpnot@users.noreply.github.com>
---
 winsup/cygwin/cygwin.din | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/winsup/cygwin/cygwin.din b/winsup/cygwin/cygwin.din
index 073b8d07f4..5f8ce5939e 100644
--- a/winsup/cygwin/cygwin.din
+++ b/winsup/cygwin/cygwin.din
@@ -1,4 +1,4 @@
-LIBRARY "msys-2.0.dll" BASE=0x180040000
+LIBRARY "msys-2.0.dll" BASE=0x210040000
 
 EXPORTS
 # Exported variables

From a9e5b630efeccab51da5e8f9e3d2451d6416ad48 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Tue, 6 Feb 2024 18:45:41 +0100
Subject: [PATCH 73/84] dependabot: help keeping GitHub Actions versions up to
 date

See https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot#enabling-dependabot-version-updates-for-actions for details.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 .github/dependabot.yml | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 .github/dependabot.yml

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000000..22d5376407
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,13 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+# especially
+# https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot#enabling-dependabot-version-updates-for-actions
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

From 01b5c831210604f2f85bf92041a41c36f35a132b Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Thu, 20 Aug 2020 12:22:05 +0200
Subject: [PATCH 74/84] Do not try to sync with Cygwin

This is a forked repository...

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 .github/workflows/sync-with-cygwin.yml | 24 ------------------------
 1 file changed, 24 deletions(-)
 delete mode 100644 .github/workflows/sync-with-cygwin.yml

diff --git a/.github/workflows/sync-with-cygwin.yml b/.github/workflows/sync-with-cygwin.yml
deleted file mode 100644
index 57bd30e5da..0000000000
--- a/.github/workflows/sync-with-cygwin.yml
+++ /dev/null
@@ -1,24 +0,0 @@
-name: sync-with-cygwin
-
-# File: .github/workflows/repo-sync.yml
-
-on:
-  workflow_dispatch:
-  schedule:
-  - cron:  "42 * * * *"
-jobs:
-  repo-sync:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-    - name: Fetch Cygwin's latest master and tags
-      run: |
-        git init --bare
-        # Potentially use git://sourceware.org/git/newlib-cygwin.git directly, but GitHub seems more reliable
-        git fetch https://github.com/cygwin/cygwin master:refs/heads/cygwin/master 'refs/tags/*:refs/tags/*'
-    - name: Push to our fork
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      run: |
-        git push https://$GITHUB_ACTOR:$GITHUB_TOKEN@github.com/$GITHUB_REPOSITORY refs/heads/cygwin/master 'refs/tags/*:refs/tags/*'

From 0119a81c4684d6090af842408498fb4d20311632 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Mon, 12 Feb 2024 17:07:13 +0100
Subject: [PATCH 75/84] ci: run Git's entire test suite

One particularly important part of Git for Windows' MSYS2 runtime is
that it is used to run Git's tests, and regressions happened there: For
example, the first iteration of MSYS2 runtime v3.5.5 caused plenty of
hangs. This was realized unfortunately only after deploying the
msys2-runtime Pacman package, and some painful vacation-time scrambling
was required to revert to v3.5.4.This was realized unfortunately only
after deploying the msys2-runtime Pacman package, and some painful
vacation-time scrambling was required to revert to v3.5.4.

To verify that this does not happen anymore, let's reuse what
`setup-git-for-windows-sdk` uses in Git's very own CI:

- determine the latest successful `ci-artifacts` workflow run in
  git-for-windows/git-sdk-64

- download its Git files and build artifacts

- download its minimal-sdk

- overwrite the MSYS2 runtime in the minimal-sdk

- run the test suite and the assorted validations just like the
  `ci-artifacts` workflow (from which these jobs are copied)

This obviously adds a hefty time penalty (around 7 minutes!) to every
MSYS2 runtime PR in the git-for-windows org. Happily, these days we
don't need many of those, and the balance between things like the v3.5.5
scramble and waiting a little longer for the CI to finish is clearly in
favor of the latter.

Co-authored-by: Jeremy Drake <github@jdrake.com>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 .github/workflows/build.yaml | 80 ++++++++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)

diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
index c680f97313..d5265f26a7 100644
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -38,6 +38,86 @@ jobs:
           name: install
           path: _dest/
 
+  minimal-sdk-artifact:
+    runs-on: windows-latest
+    needs: [build]
+    outputs:
+      git-artifacts-extract-location: ${{ steps.git-artifacts-extract-location.outputs.result }}
+    env:
+      G4W_SDK_REPO: git-for-windows/git-sdk-64
+    steps:
+      - name: get latest successful ci-artifacts run
+        # Cannot just grab from https://github.com/git-for-windows/git-sdk-64/releases/tag/ci-artifacts
+        # because we also need the git-artifacts
+        id: ci-artifacts-run-id
+        uses: actions/github-script@v8
+        with:
+          script: |
+            const [ owner, repo ] = process.env.G4W_SDK_REPO.split('/')
+            const info = await github.rest.actions.listWorkflowRuns({
+              owner,
+              repo,
+              workflow_id: 938271, // ci-artifacts.yml
+              status: 'success',
+              per_page: 1
+            })
+            return info.data.workflow_runs[0].id
+      - name: get the ci-artifacts build's artifacts
+        shell: bash
+        run: |
+          run_id=${{ steps.ci-artifacts-run-id.outputs.result }} &&
+
+          curl -H "Authorization: token ${{secrets.GITHUB_TOKEN}}" \
+            -L https://api.github.com/repos/$G4W_SDK_REPO/actions/runs/$run_id/artifacts |
+          jq -r '.artifacts[] | [.name, .archive_download_url] | @tsv' |
+          tr -d '\r' |
+          while read name url
+          do
+            echo "$name"
+            curl -H "Authorization: token ${{secrets.GITHUB_TOKEN}}" \
+              -#sLo /tmp/"$name".zip "$url" &&
+            unzip -qo /tmp/"$name".zip ||
+            exit $?
+          done
+          ls -la
+      - uses: actions/download-artifact@v5
+        with:
+          name: install
+          path: install
+      - name: overwrite MSYS2 runtime with the just-built msys2-runtime
+        shell: bash
+        run: |
+          set -x &&
+          mkdir minimal-sdk &&
+          cd minimal-sdk &&
+          tar xzf ../git-sdk-x86_64-minimal.tar.gz &&
+          tar -C ../install -cf - . | tar xf - &&
+          tar cvf - * .[0-9A-Za-z]* | gzip -1 >../git-sdk-x86_64-minimal.tar.gz
+      - name: upload minimal-sdk artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: minimal-sdk
+          path: git-sdk-x86_64-minimal.tar.gz
+      - name: run `uname`
+        run: minimal-sdk\usr\bin\uname.exe -a
+      - name: determine where `git-artifacts` want to be extracted
+        id: git-artifacts-extract-location
+        shell: bash
+        run: |
+          echo "result=$(tar Oxf git-artifacts.tar.gz git/bin-wrappers/git |
+            sed -n 's|^GIT_EXEC_PATH='\''\(.*\)/git'\''$|\1|p')" >>$GITHUB_OUTPUT
+      - name: upload git artifacts for testing
+        uses: actions/upload-artifact@v4
+        with:
+          name: git-artifacts
+          path: git-artifacts.tar.gz
+
+  test-minimal-sdk:
+    needs: [minimal-sdk-artifact]
+    uses: git-for-windows/git-sdk-64/.github/workflows/test-ci-artifacts.yml@main
+    with:
+      git-artifacts-extract-location: ${{ needs.minimal-sdk-artifact.outputs.git-artifacts-extract-location }}
+
   generate-msys2-tests-matrix:
     runs-on: ubuntu-latest
     outputs:

From f41b00262ad1cf9107cbdc05527961d78eee12db Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Fri, 10 Oct 2025 09:51:32 +0200
Subject: [PATCH 76/84] Start implementing UI-based tests by adding an
 AutoHotKey library

AutoHotKey is not only a convenient way to add keyboard shortcuts for
functionality (or applications) that does not come with shortcuts, but
it is in general a powerful language to remote control GUI elements.

We will use this language to implement a couple of automated tests that
should hopefully prevent regressions as we have experienced in the past
(for example, a regression that was fixed and immediately re-broken,
which went unnoticed for months).

So let's start by adding a library of useful functions, to be extended
as needed.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 ui-tests/ui-test-library.ahk | 125 +++++++++++++++++++++++++++++++++++
 1 file changed, 125 insertions(+)
 create mode 100644 ui-tests/ui-test-library.ahk

diff --git a/ui-tests/ui-test-library.ahk b/ui-tests/ui-test-library.ahk
new file mode 100644
index 0000000000..120e85ed76
--- /dev/null
+++ b/ui-tests/ui-test-library.ahk
@@ -0,0 +1,125 @@
+; Reusable library functions for the UI tests.
+
+SetWorkTree(defaultName) {
+    global workTree
+    ; First, set the worktree path; This path will be reused
+    ; for the `.log` file).
+    if A_Args.Length > 0
+        workTree := A_Args[1]
+    else
+    {
+        ; Create a unique worktree path in the TEMP directory.
+        workTree := EnvGet('TEMP') . '\' . defaultName
+        if FileExist(workTree)
+        {
+            counter := 0
+            while FileExist(workTree '-' counter)
+                counter++
+            workTree := workTree '-' counter
+        }
+    }
+
+    SetWorkingDir(EnvGet('TEMP'))
+    Info 'uname: ' RunWaitOne('git -c alias.uname="!uname" uname -a')
+    Info RunWaitOne('git version --build-options')
+
+    RunWait('git init "' workTree '"', '', 'Hide')
+    if A_LastError
+        ExitWithError 'Could not initialize Git worktree at: ' workTree
+
+    SetWorkingDir(workTree)
+    if A_LastError
+        ExitWithError 'Could not set working directory to: ' workTree
+}
+
+CleanUpWorkTree() {
+    global workTree
+    SetWorkingDir(EnvGet('TEMP'))
+    Info 'Cleaning up worktree: ' workTree
+    DirDelete(workTree, true)
+}
+
+Info(text) {
+    FileAppend text '`n', workTree '.log'
+}
+
+closeWindow := false
+childPid := 0
+ExitWithError(error) {
+    Info 'Error: ' error
+    if closeWindow
+       WinClose "A"
+    else if childPid != 0
+        ProcessClose childPid
+    ExitApp 1
+}
+
+RunWaitOne(command) {
+    SavedClipboard := ClipboardAll
+    shell := ComObject("WScript.Shell")
+    ; Execute a single command via cmd.exe
+    exec := shell.Run(A_ComSpec " /C " command " | clip", 0, true)
+    if exec != 0
+        ExitWithError 'Error executing command: ' command
+    ; Read and return the command's output, trimming trailing newlines.
+    Result := RegExReplace(A_Clipboard, '`r?`n$', '')
+    Clipboard := SavedClipboard
+    return Result
+}
+
+; This function is quite the hack. It assumes that the Windows Terminal is the active window,
+; then drags the mouse diagonally across the window to select all text and then copies it.
+;
+; This is fragile! If any other window becomes active, or if the mouse is moved,
+; the function will not work as intended.
+;
+; An alternative would be to use `ControlSend`, e.g.
+; `ControlSend '+^a', 'Windows.UI.Input.InputSite.WindowClass1', 'ahk_id ' . hwnd
+; This _kinda_ works, the text is selected (all text, in fact), but the PowerShell itself
+; _also_ processes the keyboard events and therefore they leave ugly and unintended
+; `^Ac` characters in the prompt. So that alternative is not really usable.
+CaptureTextFromWindowsTerminal(winTitle := '') {
+    if winTitle != ''
+        WinActivate winTitle
+    ControlGetPos &cx, &cy, &cw, &ch, 'Windows.UI.Composition.DesktopWindowContentBridge1', "A"
+    titleBarHeight := 54
+    scrollBarWidth := 28
+    pad := 8
+
+    SavedClipboard := ClipboardAll
+    A_Clipboard := ''
+    SendMode('Event')
+    if winTitle != ''
+        WinActivate winTitle
+    MouseMove cx + pad, cy + titleBarHeight + pad
+    if winTitle != ''
+        WinActivate winTitle
+    MouseClickDrag 'Left', , , cx + cw - scrollBarWidth, cy + ch - pad, , ''
+    if winTitle != ''
+        WinActivate winTitle
+    MouseClick 'Right'
+    ClipWait()
+    Result := A_Clipboard
+    Clipboard := SavedClipboard
+    return Result
+}
+
+WaitForRegExInWindowsTerminal(regex, errorMessage, successMessage, timeout := 5000, winTitle := '') {
+    timeout := timeout + A_TickCount
+    ; Wait for the regex to match in the terminal output
+    while true
+    {
+        capturedText := CaptureTextFromWindowsTerminal(winTitle)
+        if RegExMatch(capturedText, regex)
+            break
+        Sleep 100
+        if A_TickCount > timeout {
+            Info('Captured text:`n' . capturedText)
+            ExitWithError errorMessage
+        }
+        if winTitle != ''
+            WinActivate winTitle
+        MouseClick 'WheelDown', , , 20
+    }
+    Info(successMessage)
+}
\ No newline at end of file

From 8c1cae66bf80d767c121787b45a093de7d3e6a85 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Wed, 7 May 2025 11:27:42 +0200
Subject: [PATCH 77/84] ci: add an AutoHotKey-based integration test

The issue reported in https://github.com/microsoft/git/issues/730 was
fixed, but due to missing tests for the issue a regression slipped in
within mere weeks.

Let's add an integration test that will (hopefully) prevent this issue
from regressing again.

This integration test is implement as an AutoHotKey script. It might
look unnatural to use a script language designed to implement global
keyboard shortcuts, but it is a quite powerful approach. While
there are miles between the ease of developing AutoHotKey scripts and
developing, say, Playwright tests, there is a decent integration into VS
Code (including single-step debugging), and AutoHotKey's own development
and community are quite vibrant and friendly.

I had looked at alternatives to AutoHotKey, such as WinAppDriver,
SikuliX, nut.js and AutoIt, in particular searching for a solution that
would have a powerful recording feature similar to Playwright, but did
not find any that is 1) mature, 2) well-maintained, 3) open source and
4) would be easy to integrate into a GitHub workflow. In the end,
AutoHotKey appeared my clearest preference.

So how is the test implemented? It lives in `ui-test/` and requires
AutoHotKey v2 as well as Windows Terminal (the Legacy Prompt would not
reproduce the problem). It then follows the reproducer I gave to the
Cygwin team:

1. initialize a Git repository
2. install a `pre-commit` hook
3. this hook shall spawn a non-Cygwin/MSYS2 process in the background
4. that background process shall print to the console after Git exits
5. open a Command Prompt in Windows Terminal
6. run `git commit`
7. wait until the background process is done printing
8. press the Cursor Up key
9. observe that the Command Prompt does not react (in the test, it
   _does_ expect a reaction: the previous command in the command
   history should be shown, i.e. `git commit`)

In my reproducer, I then also suggested to press the Enter key and to
observe that now the "More ?" prompt is shown, but no input is accepted,
until Ctrl+Z is pressed. Naturally, the test should not expect _that_
;-)

There were a couple of complications I needed to face when developing
this test:

- I did not find any easy macro recorder for AutoHotKey that I liked. It
  would not have helped much, anyway, because intentions are hard to
  record.

- Before I realized that there is excellent AutoHotKey support in VS
  Code via the AutoHotKey++ and AutoHotKey Debug extensions, I struggled
  quite a bit to get the syntax right.

- Windows Terminal does not use classical Win32 controls that AutoHotKey
  knows well. In particular, there is no easy way to capture the text
  that is shown in the Terminal. I tried the (pretty excellent!) [OCR
  for AutoHotKey](https://github.com/Descolada/OCR), but it uses UWP OCR
  which does not recognize constructs like "C:\Users\runneradmin>"
  because it is not English (or any other human language). I ended up
  with a pretty inelegant method of selecting the text via mouse
  movements and then copying that into the clipboard. This stops
  scrolling and I worked around that by emulating the mouse wheel
  afterwards.

- Since Windows Terminal does not use classical Win32 controls, it is
  relatively hard to get to the exact bounding box of the text, as there
  is no convenient way to determine the size of the title bar or the
  amount of padding around the text. I ended up hard-coding those
  values, I'm not proud of that, but at least it works.

- Despite my expectations, `ExitApp` would not actually exit AutoHotKey
  before the spawned process exits and/or the associated window is
  closed.

For good measure, run this test both on windows-2022 (corresponding to
Windows 10) and on windows-2025 (corresponding to Windows 11).

Co-authored-by: Eu-Pin Tien <eu-pin.tien@diamond.ac.uk>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>

Converted ui-tests workflow into a test matrix that uses both the windows-2022 and windows-2025 runners.
---
 .github/workflows/build.yaml   |  8 +++
 .github/workflows/ui-tests.yml | 95 ++++++++++++++++++++++++++++++++++
 ui-tests/.gitattributes        |  1 +
 ui-tests/background-hook.ahk   | 54 +++++++++++++++++++
 4 files changed, 158 insertions(+)
 create mode 100644 .github/workflows/ui-tests.yml
 create mode 100644 ui-tests/.gitattributes
 create mode 100755 ui-tests/background-hook.ahk

diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
index d5265f26a7..abdfee9b90 100644
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -118,6 +118,14 @@ jobs:
     with:
       git-artifacts-extract-location: ${{ needs.minimal-sdk-artifact.outputs.git-artifacts-extract-location }}
 
+  ui-tests:
+    needs: build
+    uses: ./.github/workflows/ui-tests.yml
+    with:
+      msys2-runtime-artifact-name: install
+    permissions:
+      contents: read
+
   generate-msys2-tests-matrix:
     runs-on: ubuntu-latest
     outputs:
diff --git a/.github/workflows/ui-tests.yml b/.github/workflows/ui-tests.yml
new file mode 100644
index 0000000000..4574f80c0e
--- /dev/null
+++ b/.github/workflows/ui-tests.yml
@@ -0,0 +1,95 @@
+name: ui-tests
+
+on:
+  workflow_call:
+    inputs:
+      msys2-runtime-artifact-name:
+        required: true
+        type: string
+
+env:
+  AUTOHOTKEY_VERSION: 2.0.19
+  WT_VERSION: 1.22.11141.0
+
+jobs:
+  ui-tests:
+    strategy:
+      fail-fast: false
+      matrix:
+        # Corresponds to Windows Server versions
+        # See https://github.com/actions/runner-images?tab=readme-ov-file#available-images
+        os: [windows-2022, windows-2025]
+
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/download-artifact@v5
+        with:
+          name: ${{ inputs.msys2-runtime-artifact-name }}
+          path: ${{ runner.temp }}/artifacts
+      - name: replace MSYS2 runtime
+        run: |
+          $p = Get-ChildItem -Recurse "${env:RUNNER_TEMP}\artifacts" | where {$_.Name -eq "msys-2.0.dll"} | Select -ExpandProperty VersionInfo | Select -First 1 -ExpandProperty FileName
+          cp $p "c:/Program Files/Git/usr/bin/msys-2.0.dll"
+
+      - uses: actions/cache/restore@v4
+        id: restore-wt
+        with:
+          key: wt-${{ env.WT_VERSION }}
+          path: ${{ runner.temp }}/wt.zip
+      - name: Download Windows Terminal
+        if: steps.restore-wt.outputs.cache-hit != 'true'
+        shell: bash
+        run: |
+          curl -fLo "$RUNNER_TEMP/wt.zip" \
+          https://github.com/microsoft/terminal/releases/download/v$WT_VERSION/Microsoft.WindowsTerminal_${WT_VERSION}_x64.zip
+      - uses: actions/cache/save@v4
+        if: steps.restore-wt.outputs.cache-hit != 'true'
+        with:
+          key: wt-${{ env.WT_VERSION }}
+          path: ${{ runner.temp }}/wt.zip
+      - name: Install Windows Terminal
+        shell: bash
+        working-directory: ${{ runner.temp }}
+        run: |
+          "$WINDIR/system32/tar.exe" -xf "$RUNNER_TEMP/wt.zip" &&
+          cygpath -aw terminal-$WT_VERSION >>$GITHUB_PATH
+      - uses: actions/cache/restore@v4
+        id: restore-ahk
+        with:
+          key: ahk-${{ env.AUTOHOTKEY_VERSION }}
+          path: ${{ runner.temp }}/ahk.zip
+      - name: Download AutoHotKey2
+        if: steps.restore-ahk.outputs.cache-hit != 'true'
+        shell: bash
+        run: |
+          curl -L -o "$RUNNER_TEMP/ahk.zip" \
+            https://github.com/AutoHotkey/AutoHotkey/releases/download/v$AUTOHOTKEY_VERSION/AutoHotkey_$AUTOHOTKEY_VERSION.zip
+      - uses: actions/cache/save@v4
+        if: steps.restore-ahk.outputs.cache-hit != 'true'
+        with:
+          key: ahk-${{ env.AUTOHOTKEY_VERSION }}
+          path: ${{ runner.temp }}/ahk.zip
+      - name: Install AutoHotKey2
+        shell: bash
+        run: |
+          mkdir -p "$RUNNER_TEMP/ahk" &&
+          "$WINDIR/system32/tar.exe" -C "$RUNNER_TEMP/ahk" -xf "$RUNNER_TEMP/ahk.zip" &&
+          cygpath -aw "$RUNNER_TEMP/ahk" >>$GITHUB_PATH
+      - uses: actions/setup-node@v5 # the hook uses node for the background process
+
+      - uses: actions/checkout@v5
+        with:
+          sparse-checkout: |
+            ui-tests
+      - name: Run UI tests
+        id: ui-tests
+        timeout-minutes: 10
+        run: |
+          $exitCode = 0
+          & "${env:RUNNER_TEMP}\ahk\AutoHotKey64.exe" /ErrorStdOut /force ui-tests\background-hook.ahk "$PWD\bg-hook" 2>&1 | Out-Default
+          if (!$?) { $exitCode = 1; echo "::error::Test failed!" } else { echo "::notice::Test log" }
+          type bg-hook.log
+          exit $exitCode
+      - name: Show logs
+        if: always()
+        run: type bg-hook.log
diff --git a/ui-tests/.gitattributes b/ui-tests/.gitattributes
new file mode 100644
index 0000000000..4dd1b9375b
--- /dev/null
+++ b/ui-tests/.gitattributes
@@ -0,0 +1 @@
+*.ahk eol=lf
diff --git a/ui-tests/background-hook.ahk b/ui-tests/background-hook.ahk
new file mode 100755
index 0000000000..af7c27d313
--- /dev/null
+++ b/ui-tests/background-hook.ahk
@@ -0,0 +1,54 @@
+#Requires AutoHotkey v2.0
+#Include ui-test-library.ahk
+
+; This script is an integration test for the following scenario:
+; A Git hook spawns a background process that outputs some text
+; to the console even after Git has exited.
+
+; At some point in time, the Cygwin/MSYS2 runtime left the console
+; in a state where it was not possible to navigate the history via
+; CursorUp/Down, as reported in https://github.com/microsoft/git/issues/730.
+; This was fixed in the Cygwin/MSYS2 runtime, but then regressed again.
+; This test is meant to verify that the issue is fixed and remains so.
+
+SetWorkTree('git-test-background-hook')
+
+if not FileExist('.git/hooks') and not DirCreate('.git/hooks')
+    ExitWithError 'Could not create hooks directory: ' workTree
+
+FileAppend("#!/bin/sh`npowershell -command 'for ($i = 0; $i -lt 50; $i++) { echo $i; sleep -milliseconds 10 }' &`n", '.git/hooks/pre-commit')
+if A_LastError
+    ExitWithError 'Could not create pre-commit hook: ' A_LastError
+
+Run 'wt.exe -d . ' A_ComSpec ' /d', , , &childPid
+if A_LastError
+    ExitWithError 'Error launching CMD: ' A_LastError
+Info 'Launched CMD: ' childPid
+if not WinWait(A_ComSpec, , 9)
+    ExitWithError 'CMD window did not appear'
+Info 'Got window'
+WinActivate
+CloseWindow := true
+WinMove 0, 0
+Info 'Moved window to top left (so that the bottom is not cut off)'
+
+Info('Setting committer identity')
+Send('git config user.name Test{Enter}git config user.email t@e.st{Enter}')
+
+Info('Committing')
+Send('git commit --allow-empty -m zOMG{Enter}')
+; Wait for the hook to finish printing
+WaitForRegExInWindowsTerminal('`n49$', 'Timed out waiting for commit to finish', 'Hook finished', 100000)
+
+; Verify that CursorUp shows the previous command
+Send('{Up}')
+Sleep 150
+Text := CaptureTextFromWindowsTerminal()
+if not RegExMatch(Text, 'git commit --allow-empty -m zOMG *$')
+    ExitWithError 'Cursor Up did not work: ' Text
+Info('Match!')
+
+Send('^C')
+Send('exit{Enter}')
+Sleep 50
+CleanUpWorkTree()
\ No newline at end of file

From 354f2e24bb3eea74604a8d038e023dc86f664058 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Sat, 5 Jul 2025 13:54:23 +0200
Subject: [PATCH 78/84] ci(ui-tests): upload the test logs

The test logs are quite interesting to have, and not only those: In case
of a fatal failure, the test directory is valuable information, too.
Let's always upload them as build artifacts.

For convenience, let's just reuse the `ui-tests/` directory as the place
to put all of those files; Technically, we do not need the files in
there that are tracked by Git, but practically speaking, it is neat to
have them packaged in the same `.zip` file as the test logs and stuff.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 .github/workflows/ui-tests.yml | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ui-tests.yml b/.github/workflows/ui-tests.yml
index 4574f80c0e..917a6d1062 100644
--- a/.github/workflows/ui-tests.yml
+++ b/.github/workflows/ui-tests.yml
@@ -84,12 +84,20 @@ jobs:
       - name: Run UI tests
         id: ui-tests
         timeout-minutes: 10
+        working-directory: ui-tests
         run: |
           $exitCode = 0
-          & "${env:RUNNER_TEMP}\ahk\AutoHotKey64.exe" /ErrorStdOut /force ui-tests\background-hook.ahk "$PWD\bg-hook" 2>&1 | Out-Default
+          & "${env:RUNNER_TEMP}\ahk\AutoHotKey64.exe" /ErrorStdOut /force background-hook.ahk "$PWD\bg-hook" 2>&1 | Out-Default
           if (!$?) { $exitCode = 1; echo "::error::Test failed!" } else { echo "::notice::Test log" }
           type bg-hook.log
           exit $exitCode
       - name: Show logs
         if: always()
+        working-directory: ui-tests
         run: type bg-hook.log
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: ui-tests-${{ matrix.os }}
+          path: ui-tests

From 1f37a37638eb54ac556a7e18eb7a72353b1a497f Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Fri, 4 Jul 2025 11:48:15 +0200
Subject: [PATCH 79/84] ci(ui-tests): take a screenshot when canceled

Sometimes the logs are empty and it is highly unclear what has happened.
In such a scenario, a picture is indeed worth more than a thousand
words.

Note that this commit is more complicated than anyone would like, for
two reasons:

- While PowerShell is the right tool for the job, a PowerShell step in
  GitHub Actions will pop up a Terminal window, _hiding_ what we want to
  screenshot. To work around that, I tried to run things in a Bash step.
  _Also_ opens a Terminal window! Node.js to the rescue.

- _Of course_ it is complicated to take a screenshot. The challenge is
  to figure out the dimensions of the screen, which should be as easy as
  looking at `[System.Windows.Forms.Screen]::PrimaryScreen`'s `Bounds`
  attribute.

  Easy peasy, right? No, it's not. Most machines nowadays have a
  _ridiculous_ resolution which is why most setups have a _zoom factor_.
  Getting to that factor should be trivial, by calling
  `GetDeviceCaps(hDC, LOGPIXELSX)`, but that's not working in modern
  Windows! There is a per-monitor display scaling ("DPI"). But even
  _that_ is hard to get at, calling `GetDpiForMonitor()` will still
  return 96 DPI (i.e. 100% zoom) because PowerShell is not marked as
  _Per-Monitor DPI Aware_. Since we do not want to write a manifest into
  the same directory as `powershell.exe` resides, we have to jump
  through yet another hoop to get that.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 .github/workflows/ui-tests.yml | 57 ++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)

diff --git a/.github/workflows/ui-tests.yml b/.github/workflows/ui-tests.yml
index 917a6d1062..4b9f728fbf 100644
--- a/.github/workflows/ui-tests.yml
+++ b/.github/workflows/ui-tests.yml
@@ -95,6 +95,63 @@ jobs:
         if: always()
         working-directory: ui-tests
         run: type bg-hook.log
+      - name: Take screenshot, if canceled
+        id: take-screenshot
+        if: cancelled() || failure()
+        shell: powershell
+        run: |
+          Add-Type -TypeDefinition @"
+          using System;
+          using System.Runtime.InteropServices;
+
+          public class DpiHelper {
+              [DllImport("user32.dll")]
+              public static extern bool SetProcessDpiAwarenessContext(IntPtr dpiContext);
+
+              [DllImport("Shcore.dll")]
+              public static extern int GetDpiForMonitor(IntPtr hmonitor, int dpiType, out uint dpiX, out uint dpiY);
+
+              [DllImport("User32.dll")]
+              public static extern IntPtr MonitorFromPoint(System.Drawing.Point pt, uint dwFlags);
+
+              [DllImport("user32.dll")]
+              public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
+
+              public static uint GetDPI() {
+                  // DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = -4
+                  SetProcessDpiAwarenessContext((IntPtr)(-4));
+
+                  uint dpiX, dpiY;
+                  IntPtr monitor = MonitorFromPoint(new System.Drawing.Point(0, 0), 2); // MONITOR_DEFAULTTONEAREST
+                  GetDpiForMonitor(monitor, 0, out dpiX, out dpiY); // MDT_EFFECTIVE_DPI
+                  return (dpiX + dpiY) / 2;
+              }
+          }
+          "@ -ReferencedAssemblies "System.Drawing.dll"
+
+          # First, minimize the Console window in which this script is running
+          $hwnd = (Get-Process -Id $PID).MainWindowHandle
+          $SW_MINIMIZE = 6
+
+          [DpiHelper]::ShowWindow($hwnd, $SW_MINIMIZE)
+
+          # Now, get the DPI
+          $dpi = [DpiHelper]::GetDPI()
+
+          # This function takes a screenshot and saves it as a PNG file
+          [Reflection.Assembly]::LoadWithPartialName("System.Drawing")
+          function screenshot([Drawing.Rectangle]$bounds, $path) {
+            $bmp = New-Object Drawing.Bitmap $bounds.width, $bounds.height
+            $graphics = [Drawing.Graphics]::FromImage($bmp)
+            $graphics.CopyFromScreen($bounds.Location, [Drawing.Point]::Empty, $bounds.size)
+            $bmp.Save($path)
+            $graphics.Dispose()
+            $bmp.Dispose()
+          }
+          Add-Type -AssemblyName System.Windows.Forms
+          $screen = [System.Windows.Forms.Screen]::PrimaryScreen
+          $bounds = [Drawing.Rectangle]::FromLTRB(0, 0, $screen.Bounds.Width * $dpi / 96, $screen.Bounds.Height * $dpi / 96)
+          screenshot $bounds "ui-tests/screenshot.png"
       - name: Upload test results
         if: always()
         uses: actions/upload-artifact@v4

From a7c4297f5126b9853ba8a8a0aa51aee0eaf801ba Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Fri, 4 Jul 2025 01:32:51 +0200
Subject: [PATCH 80/84] ui-tests: verify that a `sleep` in Windows Terminal can
 be interrupted

The Ctrl+C way to interrupt run-away processes is highly important. It
was recently broken in multiple ways in the Cygwin runtime (and hence
also in the MSYS2 runtime).

Let's add some integration tests that will catch regressions.

It is admittedly less than ideal to add _integration_ tests; While
imitating exactly what the end user does looks appealing at first,
excellent tests impress by how quickly they allow regressions not only
to be identified but also to be fixed. Even worse: all integration
tests, by virtue of working in a broader environment than, say, unit
tests, incur the price of sometimes catching unactionable bugs, i.e.
bugs in software that is both outside of our control as well as not the
target of our testing at all.

Nevertheless, seeing as Cygwin did not add any unit tests for those
Ctrl+C fixes (which is understandable, given how complex testing for
Ctrl+C without UI testing would be), it is better to have integration
tests than no tests at all.

So here goes: This commit introduces a test that verifies that the MSYS2
`sleep.exe` can be interrupted when run from PowerShell in a Windows
Terminal. This was broken in v3.6.0 and fixed in 7674c51e18 (Cygwin:
console: Set ENABLE_PROCESSED_INPUT when disable_master_thread,
2025-07-01).

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 .github/workflows/ui-tests.yml |  7 +++++-
 ui-tests/ctrl-c.ahk            | 46 ++++++++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+), 1 deletion(-)
 create mode 100644 ui-tests/ctrl-c.ahk

diff --git a/.github/workflows/ui-tests.yml b/.github/workflows/ui-tests.yml
index 4b9f728fbf..853723b095 100644
--- a/.github/workflows/ui-tests.yml
+++ b/.github/workflows/ui-tests.yml
@@ -90,11 +90,16 @@ jobs:
           & "${env:RUNNER_TEMP}\ahk\AutoHotKey64.exe" /ErrorStdOut /force background-hook.ahk "$PWD\bg-hook" 2>&1 | Out-Default
           if (!$?) { $exitCode = 1; echo "::error::Test failed!" } else { echo "::notice::Test log" }
           type bg-hook.log
+          & "${env:RUNNER_TEMP}\ahk\AutoHotKey64.exe" /ErrorStdOut /force ctrl-c.ahk "$PWD\ctrl-c" 2>&1 | Out-Default
+          if (!$?) { $exitCode = 1; echo "::error::Ctrl+C Test failed!" } else { echo "::notice::Ctrl+C Test log" }
+          type ctrl-c.log
           exit $exitCode
       - name: Show logs
         if: always()
         working-directory: ui-tests
-        run: type bg-hook.log
+        run: |
+          type bg-hook.log
+          type ctrl-c.log
       - name: Take screenshot, if canceled
         id: take-screenshot
         if: cancelled() || failure()
diff --git a/ui-tests/ctrl-c.ahk b/ui-tests/ctrl-c.ahk
new file mode 100644
index 0000000000..10c580c218
--- /dev/null
+++ b/ui-tests/ctrl-c.ahk
@@ -0,0 +1,46 @@
+#Requires AutoHotkey v2.0
+#Include ui-test-library.ahk
+
+SetWorkTree('git-test-ctrl-c')
+
+powerShellPath := EnvGet('SystemRoot') . '\System32\WindowsPowerShell\v1.0\powershell.exe'
+Run 'wt.exe -d . "' powerShellPath '"', , , &childPid
+if A_LastError
+    ExitWithError 'Error launching PowerShell: ' A_LastError
+Info 'Launched PowerShell: ' childPid
+; Sadly, `WinWait('ahk_pid ' childPid)` does not work because the Windows Terminal window seems
+; to be owned by the `wt.exe` process that launched.
+;
+; Probably should use the trick mentioned in
+; https://www.autohotkey.com/boards/viewtopic.php?p=580081&sid=a40d0ce73efff728ffa6b4573dff07b9#p580081
+; where the `before` variable is assigned `WinGetList(winTitle).Length` before the `Run` command,
+; and a `Loop` is used to wait until [`WinGetList()`](https://www.autohotkey.com/docs/v2/lib/WinGetList.htm)
+; returns a different length, in which case the first array element is the new window.
+;
+; Also: This is crying out loud to be refactored into a function and then also used in `background-hook.ahk`!
+hwnd := WinWait(powerShellPath, , 9)
+if not hwnd
+    ExitWithError 'PowerShell window did not appear'
+Info 'Got window'
+WinActivate
+CloseWindow := true
+WinMove 0, 0
+Info 'Moved window to top left (so that the bottom is not cut off)'
+
+; sleep test
+Sleep 1500
+; The `:;` is needed to force Git to call this via the shell, otherwise `/usr/bin/` would not resolve.
+Send('git -c alias.sleep="{!}:;/usr/bin/sleep" sleep 15{Enter}')
+Sleep 500
+; interrupt sleep; Ideally we'd call `Send('^C')` but that would too quick on GitHub Actions' runners.
+; The idea for this work-around comes from https://www.reddit.com/r/AutoHotkey/comments/aok10s/comment/eg57e81/.
+Send '{Ctrl down}{c down}'
+Sleep 50
+Send '{c up}{Ctrl up}'
+Sleep 150
+; Wait for the `^C` tell-tale that is the PowerShell prompt to appear
+WaitForRegExInWindowsTerminal('>[ `n`r]*$', 'Timed out waiting for interrupt', 'Sleep was interrupted as desired')
+
+Send('exit{Enter}')
+Sleep 50
+CleanUpWorkTree()
\ No newline at end of file

From d59282b52afdfb212429501b47db2a03645146e1 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Fri, 4 Jul 2025 01:44:33 +0200
Subject: [PATCH 81/84] ui-tests: verify that interrupting clones via SSH works

This was the actual use case that was broken and necessitated the fix in
7674c51e18 (Cygwin: console: Set ENABLE_PROCESSED_INPUT when
disable_master_thread, 2025-07-01).

It does require an SSH server, which Git for Windows no longer ships.
Therefore, this test uses the `sshd.exe` of OpenSSH for Windows
(https://github.com/powershell/Win32-OpenSSH) in conjunction with Git
for Windows' `ssh.exe` (because using OpenSSH for Windows' variant of
`ssh.exe` would not exercise the MSYS2 runtime and therefore not
demonstrate a regression, should it surface in the future).

To avoid failing the test because OpenSSH for Windows is not available,
the test case is guarded by the environment variable
`OPENSSH_FOR_WINDOWS_DIRECTORY` which needs to point to a directory that
contains a working `sshd.exe`.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 .github/workflows/ui-tests.yml | 22 +++++++++
 ui-tests/ctrl-c.ahk            | 87 ++++++++++++++++++++++++++++++++++
 2 files changed, 109 insertions(+)

diff --git a/.github/workflows/ui-tests.yml b/.github/workflows/ui-tests.yml
index 853723b095..a363709a68 100644
--- a/.github/workflows/ui-tests.yml
+++ b/.github/workflows/ui-tests.yml
@@ -10,6 +10,7 @@ on:
 env:
   AUTOHOTKEY_VERSION: 2.0.19
   WT_VERSION: 1.22.11141.0
+  WIN32_OPENSSH_VERSION: 9.8.3.0p2-Preview
 
 jobs:
   ui-tests:
@@ -76,6 +77,27 @@ jobs:
           "$WINDIR/system32/tar.exe" -C "$RUNNER_TEMP/ahk" -xf "$RUNNER_TEMP/ahk.zip" &&
           cygpath -aw "$RUNNER_TEMP/ahk" >>$GITHUB_PATH
       - uses: actions/setup-node@v5 # the hook uses node for the background process
+      - uses: actions/cache/restore@v4
+        id: restore-win32-openssh
+        with:
+          key: win32-openssh-${{ env.WIN32_OPENSSH_VERSION }}
+          path: ${{ runner.temp }}/win32-openssh.zip
+      - name: Download Win32-OpenSSH
+        if: steps.restore-win32-openssh.outputs.cache-hit != 'true'
+        shell: bash
+        run: |
+          curl -fLo "$RUNNER_TEMP/win32-openssh.zip" \
+            https://github.com/PowerShell/Win32-OpenSSH/releases/download/v$WIN32_OPENSSH_VERSION/OpenSSH-Win64.zip
+      - uses: actions/cache/save@v4
+        if: steps.restore-win32-openssh.outputs.cache-hit != 'true'
+        with:
+          key: win32-openssh-${{ env.WIN32_OPENSSH_VERSION }}
+          path: ${{ runner.temp }}/win32-openssh.zip
+      - name: Unpack Win32-OpenSSH
+        shell: bash
+        run: |
+          "$WINDIR/system32/tar.exe" -C "$RUNNER_TEMP" -xvf "$RUNNER_TEMP/win32-openssh.zip" &&
+          echo "OPENSSH_FOR_WINDOWS_DIRECTORY=$(cygpath -aw "$RUNNER_TEMP/OpenSSH-Win64")" >>$GITHUB_ENV
 
       - uses: actions/checkout@v5
         with:
diff --git a/ui-tests/ctrl-c.ahk b/ui-tests/ctrl-c.ahk
index 10c580c218..9e382ede7a 100644
--- a/ui-tests/ctrl-c.ahk
+++ b/ui-tests/ctrl-c.ahk
@@ -41,6 +41,93 @@ Sleep 150
 ; Wait for the `^C` tell-tale that is the PowerShell prompt to appear
 WaitForRegExInWindowsTerminal('>[ `n`r]*$', 'Timed out waiting for interrupt', 'Sleep was interrupted as desired')
 
+; Clone via SSH test; Requires an OpenSSH for Windows `sshd.exe` whose directory needs to be specified via
+; the environment variable `OPENSSH_FOR_WINDOWS_DIRECTORY`. The clone will still be performed via Git's
+; included `ssh.exe`, to exercise the MSYS2 runtime (which these UI tests are all about).
+
+openSSHPath := EnvGet('OPENSSH_FOR_WINDOWS_DIRECTORY')
+if (openSSHPath != '' and FileExist(openSSHPath . '\sshd.exe')) {
+    Info('Generate 26M of data')
+    RunWait('git init --bare -b main large.git', '', 'Hide')
+    RunWait('git --git-dir=large.git -c alias.c="!(' .
+        'printf \"reset refs/heads/main\\n\"; ' .
+        'seq 100000 | ' .
+        'sed \"s|.*|blob\\nmark :&\\ndata <<E\\n&\\nE\\ncommit refs/heads/main\\n' .
+            'committer a <a@b.c> 1234& +0000\\ndata <<E\\n&\\nE\\nM 100644 :& file|\"' .
+    ') | git fast-import" c', '', 'Hide')
+    Info('Done generating 26M of data')
+
+    ; When running as administrator, `ssh-keygen` will generate files with
+    ; too-open permissions by default; Let's adjust them.
+    AdjustPermissions(path) {
+        if not A_IsAdmin
+            return
+        RunWait('icacls ' . path . ' /inheritance:r')
+        if A_LastError
+            ExitWithError 'Could not adjust ACL inheritance of ' . path . ': ' A_LastError
+        RunWait('icacls ' . path . ' /remove "NT AUTHORITY\Authenticated Users"')
+        if A_LastError
+            ExitWithError 'Could not remove authenticated user permission from ' . path . ': ' A_LastError
+        RunWait('icacls ' . path . ' /grant "Administrators:(R)"')
+        if A_LastError
+            ExitWithError 'Could not add admin read permission from ' . path . ': ' A_LastError
+    }
+
+    ; Set up SSH server
+    Info('Generating host key')
+    RunWait('git -c alias.c="!ssh-keygen -b 4096 -f ssh_host_rsa_key -N \"\"" c', '', 'Hide')
+    if A_LastError
+        ExitWithError 'Error generating host key: ' A_LastError
+    AdjustPermissions('ssh_host_rsa_key')
+    AdjustPermissions('ssh_host_rsa_key.pub')
+    Info('Generating client key')
+    RunWait('git -c alias.c="!ssh-keygen -f id_rsa -N \"\"" c', '', 'Hide')
+    if A_LastError
+        ExitWithError 'Error generating client key: ' A_LastError
+    AdjustPermissions('id_rsa')
+    AdjustPermissions('id_rsa.pub')
+    FileAppend('Port 2322`n' .
+        'HostKey "' . workTree . '\ssh_host_rsa_key"`n' .
+        'AuthorizedKeysFile "' . workTree . '\id_rsa.pub"`n',
+        'sshd_config')
+    sshdOptions := '-f "' . workTree . '\sshd_config" -D -d -d -d -E sshd.log'
+
+    ; Start SSH server
+    Info('Starting SSH server')
+    Run(openSSHPath . '\sshd.exe ' . sshdOptions, '', 'Hide', &sshdPID)
+    if A_LastError
+        ExitWithError 'Error starting SSH server: ' A_LastError
+    Info('Started SSH server: ' sshdPID)
+
+    Info('Starting clone')
+    workTreeMSYS := RunWaitOne('git -c alias.cygpath="!cygpath" cygpath -u "' . workTree . '"')
+    sshOptions := '-i ' . workTreeMSYS . '/id_rsa -p 2322 -T ' .
+        '-o UserKnownHostsFile=' . workTreeMSYS . '/known_hosts ' .
+        '-o StrictHostKeyChecking=accept-new '
+    ; The `--upload-pack` option is needed because OpenSSH for Windows' default shell
+    ; is `cmd.exe`, which does not handle single-quoted strings as Git expects.
+    ; An heavy-handed alternative would be to require PowerShell to be configured via
+    ; HKLM:\SOFTWARE\OpenSSH's DefaultShell property, for full details see
+    ; https://github.com/PowerShell/Win32-OpenSSH/wiki/Setting-up-a-Git-server-on-Windows-using-Git-for-Windows-and-Win32_OpenSSH
+    ;
+    ; The username is needed because by default, on domain-joined machines MSYS2's
+    ; `ssh.exe` prefixes the username with the domain name.
+    cloneOptions := '--upload-pack="powershell git upload-pack" ' .
+        EnvGet('USERNAME') . '@localhost:' . workTree . '\large.git large-clone'
+    Send('git -c core.sshCommand="ssh ' . sshOptions . '" clone ' . cloneOptions . '{Enter}')
+    Sleep 50
+    Info('Waiting for clone to start')
+    WinActivate('ahk_id ' . hwnd)
+    WaitForRegExInWindowsTerminal('remote: ', 'Timed out waiting for clone to start', 'Clone started', 5000, 'ahk_id ' . hwnd)
+    Info('Trying to interrupt clone')
+    Send('^C') ; interrupt clone
+    Sleep 150
+    WaitForRegExInWindowsTerminal('`nfatal: (.*`r?`n){1,3}PS .*>[ `n`r]*$', 'Timed out waiting for clone to be interrupted', 'clone was interrupted as desired')
+
+    if DirExist(workTree . '\large-clone')
+        ExitWithError('`large-clone` was unexpectedly not deleted on interrupt')
+}
+
 Send('exit{Enter}')
 Sleep 50
 CleanUpWorkTree()
\ No newline at end of file

From b98e5fb1c678cd413fd0f40bf99bd9dd31cefa83 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Sat, 5 Jul 2025 20:01:34 +0200
Subject: [PATCH 82/84] ci(ui-tests): exclude the large repository from the
 build artifact

In the previous commit, I added a new UI test that generates a somewhat
large repository for testing the clone via SSH. Since that repository is
created in the test directory, that would inflate the `ui-tests` build
artifact rather dramatically. So let's create the repository outside of
that directory.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 .github/workflows/ui-tests.yml |  1 +
 ui-tests/ctrl-c.ahk            | 15 ++++++++++-----
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/ui-tests.yml b/.github/workflows/ui-tests.yml
index a363709a68..919738a268 100644
--- a/.github/workflows/ui-tests.yml
+++ b/.github/workflows/ui-tests.yml
@@ -112,6 +112,7 @@ jobs:
           & "${env:RUNNER_TEMP}\ahk\AutoHotKey64.exe" /ErrorStdOut /force background-hook.ahk "$PWD\bg-hook" 2>&1 | Out-Default
           if (!$?) { $exitCode = 1; echo "::error::Test failed!" } else { echo "::notice::Test log" }
           type bg-hook.log
+          $env:LARGE_FILES_DIRECTORY = "${env:RUNNER_TEMP}\large"
           & "${env:RUNNER_TEMP}\ahk\AutoHotKey64.exe" /ErrorStdOut /force ctrl-c.ahk "$PWD\ctrl-c" 2>&1 | Out-Default
           if (!$?) { $exitCode = 1; echo "::error::Ctrl+C Test failed!" } else { echo "::notice::Ctrl+C Test log" }
           type ctrl-c.log
diff --git a/ui-tests/ctrl-c.ahk b/ui-tests/ctrl-c.ahk
index 9e382ede7a..3150d82605 100644
--- a/ui-tests/ctrl-c.ahk
+++ b/ui-tests/ctrl-c.ahk
@@ -48,8 +48,13 @@ WaitForRegExInWindowsTerminal('>[ `n`r]*$', 'Timed out waiting for interrupt', '
 openSSHPath := EnvGet('OPENSSH_FOR_WINDOWS_DIRECTORY')
 if (openSSHPath != '' and FileExist(openSSHPath . '\sshd.exe')) {
     Info('Generate 26M of data')
-    RunWait('git init --bare -b main large.git', '', 'Hide')
-    RunWait('git --git-dir=large.git -c alias.c="!(' .
+    largeFilesDirectory := EnvGet('LARGE_FILES_DIRECTORY')
+    if largeFilesDirectory == ''
+        largeFilesDirectory := workTree . '-large-files'
+    largeGitRepoPath := largeFilesDirectory . '\large.git'
+    largeGitClonePath := largeFilesDirectory . '\large-clone'
+    RunWait('git init --bare -b main "' . largeGitRepoPath . '"', '', 'Hide')
+    RunWait('git --git-dir="' . largeGitRepoPath . '" -c alias.c="!(' .
         'printf \"reset refs/heads/main\\n\"; ' .
         'seq 100000 | ' .
         'sed \"s|.*|blob\\nmark :&\\ndata <<E\\n&\\nE\\ncommit refs/heads/main\\n' .
@@ -112,8 +117,8 @@ if (openSSHPath != '' and FileExist(openSSHPath . '\sshd.exe')) {
     ;
     ; The username is needed because by default, on domain-joined machines MSYS2's
     ; `ssh.exe` prefixes the username with the domain name.
-    cloneOptions := '--upload-pack="powershell git upload-pack" ' .
-        EnvGet('USERNAME') . '@localhost:' . workTree . '\large.git large-clone'
+    cloneOptions := '--upload-pack="powershell git upload-pack" "' .
+        EnvGet('USERNAME') . '@localhost:' . largeGitRepoPath . '" "' . largeGitClonePath . '"'
     Send('git -c core.sshCommand="ssh ' . sshOptions . '" clone ' . cloneOptions . '{Enter}')
     Sleep 50
     Info('Waiting for clone to start')
@@ -124,7 +129,7 @@ if (openSSHPath != '' and FileExist(openSSHPath . '\sshd.exe')) {
     Sleep 150
     WaitForRegExInWindowsTerminal('`nfatal: (.*`r?`n){1,3}PS .*>[ `n`r]*$', 'Timed out waiting for clone to be interrupted', 'clone was interrupted as desired')
 
-    if DirExist(workTree . '\large-clone')
+    if DirExist(largeGitClonePath)
         ExitWithError('`large-clone` was unexpectedly not deleted on interrupt')
 }
 

From ee3f04ad5f3767eebcef31e60b17b3afa8717bce Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Fri, 4 Jul 2025 01:58:20 +0200
Subject: [PATCH 83/84] ui-tests: add `ping` interrupt test

The fixes of 7674c51e18 (Cygwin: console: Set ENABLE_PROCESSED_INPUT
when disable_master_thread, 2025-07-01) were unfortunately not complete;
There were still a couple of edge cases where Ctrl+C was unable to
interrupt processes. Let's add a demonstration of that issue.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 ui-tests/ctrl-c.ahk | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/ui-tests/ctrl-c.ahk b/ui-tests/ctrl-c.ahk
index 3150d82605..4e14608180 100644
--- a/ui-tests/ctrl-c.ahk
+++ b/ui-tests/ctrl-c.ahk
@@ -41,6 +41,17 @@ Sleep 150
 ; Wait for the `^C` tell-tale that is the PowerShell prompt to appear
 WaitForRegExInWindowsTerminal('>[ `n`r]*$', 'Timed out waiting for interrupt', 'Sleep was interrupted as desired')
 
+; ping test (`cat.exe` should be interrupted, too)
+Send('git -c alias.c="{!}cat | /c/windows/system32/ping -t localhost" c{Enter}')
+Sleep 500
+WaitForRegExInWindowsTerminal('Pinging ', 'Timed out waiting for pinging to start', 'Pinging started')
+Send('^C') ; interrupt ping and cat
+Sleep 150
+; Wait for the `^C` tell-tale to appear
+WaitForRegExInWindowsTerminal('Control-C', 'Timed out waiting for pinging to be interrupted', 'Pinging was interrupted as desired')
+; Wait for the `^C` tell-tale that is the PowerShell prompt to appear
+WaitForRegExInWindowsTerminal('>[ `n`r]*$', 'Timed out waiting for `cat.exe` to be interrupted', '`cat.exe` was interrupted as desired')
+
 ; Clone via SSH test; Requires an OpenSSH for Windows `sshd.exe` whose directory needs to be specified via
 ; the environment variable `OPENSSH_FOR_WINDOWS_DIRECTORY`. The clone will still be performed via Git's
 ; included `ssh.exe`, to exercise the MSYS2 runtime (which these UI tests are all about).

From ce42fe30da3101805f29d0fe6b05b837309da861 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johannes.schindelin@gmx.de>
Date: Sat, 5 Jul 2025 18:46:47 +0200
Subject: [PATCH 84/84] ui-tests: do verify the SSH hang fix
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

In 0ae6a6fa74 (Cygwin: pipe: Fix SSH hang with non-cygwin pipe reader,
2025-06-27), a quite problematic bug was fixed where somewhat large-ish
repositories could not be cloned via SSH anymore.

This fix was not accompanied by a corresponding test case in Cygwin's
test suite, i.e. there is no automated way to ensure that there won't be
any regressions on that bug (and therefore it would fall onto end users
to deal with those).

This constitutes what Michael C. Feathers famously characterized as
"legacy code" in his book "Working Effectively with Legacy Code":

    To me, legacy code is simply code without tests. I've gotten some
    grief for this definition. What do tests have to do with whether
    code is bad? To me, the answer is straightforward, and it is a point
    that I elaborate throughout the book:

	Code without tests is bad code. It doesn’t matter how well
	written it is; it doesn’t matter how pretty or object-oriented
	or well-encapsulated it is. With tests, we can change the
	behavior of our code quickly and verifiably. Without them, we
	really don’t know if our code is getting better or worse.

Just to drive this point home, let me pull out Exhibit A: The bug fix in
question, which is the latest (and hopefully last) commit in a _long_
chain of bug fixes that fix bugs introduced by preceding bug fixes:

- 9e4d308cd5 (Cygwin: pipe: Adopt FILE_SYNCHRONOUS_IO_NONALERT flag for
  read pipe., 2021-11-10) fixed a bug where Cygwin hung by mistake while
  piping output from one .NET program as input to another .NET program
  (potentially introduced by 365199090c (Cygwin: pipe: Avoid false EOF
  while reading output of C# programs., 2021-11-07), which was itself a
  bug fix). It introduced a bug that was fixed by...
- fc691d0246 (Cygwin: pipe: Make sure to set read pipe non-blocking for
  cygwin apps., 2024-03-11). Which introduced a bug that was purportedly
  fixed by...
- 7ed9adb356 (Cygwin: pipe: Switch pipe mode to blocking mode by
  default, 2024-09-05). Which introduced a bug that was fixed by...
- cbfaeba4f7 (Cygwin: pipe: Fix incorrect write length in raw_write(),
  2024-11-06). Which introduced a bug that was fixed by... the SSH hang
  fix in 0ae6a6fa74 (Cygwin: pipe: Fix SSH hang with non-cygwin pipe
  reader, 2025-06-27).

There is not only the common thread here that each of these bug fixes
introduced a new bug, but also the common thread that none of the
commits introduced new test cases into the test suite that could
potentially have helped prevent future breakages in this code.

So let's at least add an integration test here.

Side note: I am quite unhappy with introducing integration tests. I know
there are a lot of fans out there, but I cannot help wondering whether
they favor the convenience of writing tests quickly over the vast cost
of making debugging any regression a highly cumbersome and unenjoyable
affair (try single-stepping through a test case that requires several
processes to be orchestrated in unison). Also, integration tests have
the large price of introducing moving parts outside the code base that
is actually to be tested, opening the door for breakages caused by
software (or infrastructure, think: network glitches!) that are
completely outside the power or responsibility of the poor engineer
tasked with fixing the breakages. Nevertheless, I have been unable
despite days of trying to wrap my head around the issue to figure out a
way to reproduce the `fhandler_pipe_fifo::raw_write()` hang without
involving a MINGW `git.exe` and an MSYS2/Cygwin `ssh.exe`. So: It's the
best I could do with any reasonable amount of effort. It's better to
have integration tests that would demonstrate regressions than not
having any tests for that at all.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 ui-tests/ctrl-c.ahk | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/ui-tests/ctrl-c.ahk b/ui-tests/ctrl-c.ahk
index 4e14608180..3ca8873de7 100644
--- a/ui-tests/ctrl-c.ahk
+++ b/ui-tests/ctrl-c.ahk
@@ -142,6 +142,23 @@ if (openSSHPath != '' and FileExist(openSSHPath . '\sshd.exe')) {
 
     if DirExist(largeGitClonePath)
         ExitWithError('`large-clone` was unexpectedly not deleted on interrupt')
+
+    ; Now verify that the SSH-based clone actually works and does not hang
+    Info('Re-starting SSH server')
+    Run(openSSHPath . '\sshd.exe ' . sshdOptions, '', 'Hide', &sshdPID)
+    if A_LastError
+        ExitWithError 'Error starting SSH server: ' A_LastError
+    Info('Started SSH server: ' sshdPID)
+
+    Info('Starting clone')
+    Send('git -c core.sshCommand="ssh ' . sshOptions . '" clone ' . cloneOptions . '{Enter}')
+    Sleep 500
+    Info('Waiting for clone to finish')
+    WinActivate('ahk_id ' . hwnd)
+    WaitForRegExInWindowsTerminal('Receiving objects: .*, done\.`r?`nPS .*>[ `n`r]*$', 'Timed out waiting for clone to finish', 'Clone finished', 15000, 'ahk_id ' . hwnd)
+
+    if not DirExist(largeGitClonePath)
+        ExitWithError('`large-clone` did not work?!?')
 }
 
 Send('exit{Enter}')