path.c: translate Windows paths recorded by Windows git on POSIX hosts

When `git worktree add` is run from native Windows, git writes
absolute paths into the worktree's `.git` file, into
`<commondir>/worktrees/<id>/gitdir`, and (when present) into
`<commondir>/commondir`, in `<x>:/...` or `<x>:\...` form. Reading
those files back from a non-Windows-native build of git fails because
neither form is meaningful on POSIX, so the worktree appears broken
even though every byte of it is reachable - the most common scenario
being a worktree on a Windows drive opened from inside WSL2 (where
the Windows filesystem is mounted at `/mnt/<x>/`) or from Cygwin/MSYS
(where it is `/cygdrive/<x>/`).

Add a small helper `translate_windows_path()` that recognises this
shape at the start of a path and rewrites it to the POSIX mount form
appropriate for the current build (`/cygdrive/<x>/` on Cygwin,
`/mnt/<x>/` everywhere else), converting any backslashes in the
remainder to forward slashes. Call it at the three places where
non-Windows-native git reads a recorded worktree-related path back
from disk:

  * `read_gitfile_gently()` - the `gitdir:` line in a worktree's
    `.git` file.
  * `get_common_dir_noenv()` - the `commondir` file inside a
    worktree's git directory, which points at the main repo.
  * `get_linked_worktree()` - the `gitdir` file inside
    `<commondir>/worktrees/<id>/`, which points at the worktree's
    `.git` link.

Translation only happens for `<x>:/` or `<x>:\` where `<x>` is a
single ASCII letter; anything else is left alone. The helper is a
no-op on `GIT_WINDOWS_NATIVE` builds, where the input is already in
native form. On non-WSL Linux hosts the translation still produces
a syntactically valid POSIX path; if the corresponding `/mnt/<x>/`
mount does not exist, the next stat()/open() fails as it would have
without translation - i.e. the change cannot make a working
configuration stop working.

Add a `translate_windows_path` subcommand to the path-utils test tool
and cover it in `t/t0060-path-utils.sh`. The test fixtures pick the
expected prefix from the CYGWIN prereq so the same suite passes on
Linux and Cygwin builds.

Signed-off-by: johnnyshields <27655+johnnyshields@users.noreply.github.com>

Author: johnnyshields

path.c

@@ -18,6 +18,49 @@
 #include "lockfile.h"
 #include "exec-cmd.h"
 
+int translate_windows_path(struct strbuf *path)
+{
+#ifndef GIT_WINDOWS_NATIVE
+#ifdef __CYGWIN__
+	static const char drive_prefix[] = "/cygdrive/";
+#else
+	static const char drive_prefix[] = "/mnt/";
+#endif
+	const size_t drive_prefix_len = sizeof(drive_prefix) - 1;
+	const size_t expansion = drive_prefix_len + 1 - 2;
+	char drive;
+	size_t i;
+
+	if (path->len < 3)
+		return 0;
+	if (!isalpha((unsigned char)path->buf[0]))
+		return 0;
+	if (path->buf[1] != ':')
+		return 0;
+	if (path->buf[2] != '/' && path->buf[2] != '\\')
+		return 0;
+
+	drive = tolower((unsigned char)path->buf[0]);
+
+	/* Rewrite "<letter>:" as "<drive_prefix><drive>", then convert any
+	 * backslashes in the remaining path to forward slashes. */
+	strbuf_grow(path, expansion);
+	memmove(path->buf + 2 + expansion, path->buf + 2, path->len - 2 + 1);
+	memcpy(path->buf, drive_prefix, drive_prefix_len);
+	path->buf[drive_prefix_len] = drive;
+	path->len += expansion;
+
+	for (i = drive_prefix_len + 1; i < path->len; i++) {
+		if (path->buf[i] == '\\')
+			path->buf[i] = '/';
+	}
+	return 1;
+#else
+	(void)path;
+	return 0;
+#endif
+}
+
 static int get_st_mode_bits(const char *path, int *mode)
 {
 	struct stat st;

path.h

@@ -6,6 +6,23 @@ struct strbuf;
 struct string_list;
 struct worktree;
 
+/*
+ * Translate Windows-style absolute paths (`<x>:/...` or `<x>:\...`) recorded
+ * by git running on native Windows into the POSIX mount form used by the
+ * current build:
+ *
+ *   * Cygwin / MSYS:    `/cygdrive/<x>/...`
+ *   * everything else:  `/mnt/<x>/...`  (suits WSL2, harmless elsewhere)
+ *
+ * Edits `path` in place; the strbuf may grow. Backslashes in the remainder
+ * are converted to forward slashes. Returns 1 if a translation occurred,
+ * 0 otherwise.
+ *
+ * No-op on native Windows builds, where the input is already in the native
+ * form.
+ */
+int translate_windows_path(struct strbuf *path);
+
 /*
  * The result to all functions which return statically allocated memory may be
  * overwritten by another call to _any_ one of these functions. Consider using

setup.c

@@ -336,6 +336,7 @@ int get_common_dir_noenv(struct strbuf *sb, const char *gitdir)
 			data.len--;
 		data.buf[data.len] = '\0';
 		strbuf_reset(&path);
+		translate_windows_path(&data);
 		if (!is_absolute_path(data.buf))
 			strbuf_addf(&path, "%s/", gitdir);
 		strbuf_addbuf(&path, &data);
@@ -1009,6 +1010,21 @@ const char *read_gitfile_gently(const char *path, int *return_error_code)
 	buf[len] = '\0';
 	dir = buf + 8;
 
+#ifndef GIT_WINDOWS_NATIVE
+	{
+		struct strbuf translated = STRBUF_INIT;
+		strbuf_addstr(&translated, dir);
+		if (translate_windows_path(&translated)) {
+			char *new_buf = xstrfmt("gitdir: %s", translated.buf);
+			free(buf);
+			buf = new_buf;
+			len = strlen(buf);
+			dir = buf + 8;
+		}
+		strbuf_release(&translated);
+	}
+#endif
+
 	if (!is_absolute_path(dir) && (slash = strrchr(path, '/'))) {
 		size_t pathlen = slash+1 - path;
 		dir = xstrfmt("%.*s%.*s", (int)pathlen, path,

t/helper/test-path-utils.c

@@ -401,6 +401,15 @@ int cmd__path_utils(int argc, const char **argv)
 		return 0;
 	}
 
+	if (argc == 3 && !strcmp(argv[1], "translate_windows_path")) {
+		struct strbuf sb = STRBUF_INIT;
+		strbuf_addstr(&sb, argv[2]);
+		translate_windows_path(&sb);
+		puts(sb.buf);
+		strbuf_release(&sb);
+		return 0;
+	}
+
 	if (argc == 4 && !strcmp(argv[1], "relative_path")) {
 		struct strbuf sb = STRBUF_INIT;
 		const char *in, *prefix, *rel;

t/t0060-path-utils.sh

@@ -611,4 +611,36 @@ test_expect_success !VALGRIND,RUNTIME_PREFIX,CAN_EXEC_IN_PWD '%(prefix)/ works'
 	test_cmp expect actual
 '
 
+# translate_windows_path is a no-op when git is built for native Windows
+# (the input is already in the native form). On Cygwin the mount root is
+# /cygdrive/<x>; everywhere else it is /mnt/<x>.
+if test_have_prereq CYGWIN
+then
+	WSL_DRIVE_PREFIX=/cygdrive
+else
+	WSL_DRIVE_PREFIX=/mnt
+fi
+
+translate_windows_path() {
+	test_expect_success !MINGW "translate_windows_path: $1 => $2" "
+		echo '$2' >expect &&
+		test-tool path-utils translate_windows_path '$1' >actual &&
+		test_cmp expect actual
+	"
+}
+
+translate_windows_path 'C:/foo/bar'                  "$WSL_DRIVE_PREFIX/c/foo/bar"
+translate_windows_path 'C:\\foo\\bar'                "$WSL_DRIVE_PREFIX/c/foo/bar"
+translate_windows_path 'D:/repo/.git/worktrees/wt'   "$WSL_DRIVE_PREFIX/d/repo/.git/worktrees/wt"
+translate_windows_path 'Z:\\path\\with mixed/seps'   "$WSL_DRIVE_PREFIX/z/path/with mixed/seps"
+translate_windows_path 'c:/already-lower'            "$WSL_DRIVE_PREFIX/c/already-lower"
+
+# Inputs that must NOT be translated:
+translate_windows_path '/already/posix'              '/already/posix'
+translate_windows_path 'relative/path'               'relative/path'
+translate_windows_path 'C:relative-no-separator'     'C:relative-no-separator'
+translate_windows_path '1:/digit-prefix'             '1:/digit-prefix'
+translate_windows_path 'C'                           'C'
+translate_windows_path ''                            ''
+
 test_done

worktree.c

@@ -155,6 +155,9 @@ struct worktree *get_linked_worktree(const char *id,
 	strbuf_rtrim(&worktree_path);
 	strbuf_strip_suffix(&worktree_path, "/.git");
 
+	/* Worktree path may have been recorded by git running on Windows. */
+	translate_windows_path(&worktree_path);
+
 	if (!is_absolute_path(worktree_path.buf)) {
 		strbuf_strip_suffix(&path, "gitdir");
 		strbuf_addbuf(&path, &worktree_path);