Commit 3f9294c73501f55bcba1fe8b5da1ad2f2b0af9e5 | zig

author	Ryan Liptak <squeek502@hotmail.com> 2023-08-11 14:19:59-07:00
committer	Ryan Liptak <squeek502@hotmail.com> 2023-08-11 18:58:40-07:00
log	3f9294c73501f55bcba1fe8b5da1ad2f2b0af9e5
tree	86fce350a6c04eeffbc28f9860865090e8115256
parent	ac95cfe4496a5504b42bf37b02f34eff390fe956

Windows: Fix `TooManyParentDirs` handling for paths that shouldn't be cwd-relative

Previously, a relative path like `..` would:
- Attempt to be normalized (i.e. remove . and .. without any path resolution), but would error with TooManyParentDirs
- This would make wToPrefixedFileW run it through `RtlGetFullPathName_U` to do the necessary path resolution, but `RtlGetFullPathName_U` always resolves relative paths relative to the CWD

Instead, when TooManyParentDirs occurs, we now look up the path of the passed in `dir` (if it's non-null) and append the relative path to it before giving it to `RtlGetFullPathName_U`. If `dir` is null, then we just give it RtlGetFullPathName_U directly and let it resolve it relative to the CWD.

Closes #16779

6 files changed, 112 insertions(+), 72 deletions(-)

lib
- std
  - child_process.zig
  - dynamic_library.zig
  - fs.zig
  - os.zig
  - os
    windows.zig
    windows
    test.zig

lib/std/child_process.zig+1-1

...	@@ -961,7 +961,7 @@ fn windowsCreateProcessPathExt(	...	@@ -961,7 +961,7 @@ fn windowsCreateProcessPathExt(
961	try dir_buf.append(allocator, 0);	961	try dir_buf.append(allocator, 0);
962	defer dir_buf.shrinkRetainingCapacity(dir_path_len);	962	defer dir_buf.shrinkRetainingCapacity(dir_path_len);
963	const dir_path_z = dir_buf.items[0 .. dir_buf.items.len - 1 :0];	963	const dir_path_z = dir_buf.items[0 .. dir_buf.items.len - 1 :0];
964	const prefixed_path = try windows.wToPrefixedFileW(dir_path_z);	964	const prefixed_path = try windows.wToPrefixedFileW(null, dir_path_z);
965	break :dir fs.cwd().openDirW(prefixed_path.span().ptr, .{}, true) catch return error.FileNotFound;	965	break :dir fs.cwd().openDirW(prefixed_path.span().ptr, .{}, true) catch return error.FileNotFound;
966	};	966	};
967	defer dir.close();	967	defer dir.close();

lib/std/dynamic_library.zig+2-2

...	@@ -317,12 +317,12 @@ pub const WindowsDynLib = struct {	...	@@ -317,12 +317,12 @@ pub const WindowsDynLib = struct {
317	dll: windows.HMODULE,	317	dll: windows.HMODULE,
318		318
319	pub fn open(path: []const u8) !WindowsDynLib {	319	pub fn open(path: []const u8) !WindowsDynLib {
320	const path_w = try windows.sliceToPrefixedFileW(path);	320	const path_w = try windows.sliceToPrefixedFileW(null, path);
321	return openW(path_w.span().ptr);	321	return openW(path_w.span().ptr);
322	}	322	}
323		323
324	pub fn openZ(path_c: [*:0]const u8) !WindowsDynLib {	324	pub fn openZ(path_c: [*:0]const u8) !WindowsDynLib {
325	const path_w = try windows.cStrToPrefixedFileW(path_c);	325	const path_w = try windows.cStrToPrefixedFileW(null, path_c);
326	return openW(path_w.span().ptr);	326	return openW(path_w.span().ptr);
327	}	327	}
328		328

lib/std/fs.zig+28-22

lib/std/os.zig+37-31

lib/std/os/windows.zig+42-14

 @@ -170,7 +170,7 @@ pub fn CreatePipe(rd: *HANDLE, wr: *HANDLE, sattr: *const SECURITY_ATTRIBUTES) C
 }
 pub fn CreateEventEx(attributes: ?*SECURITY_ATTRIBUTES, name: []const u8, flags: DWORD, desired_access: DWORD) !HANDLE {
-    const nameW = try sliceToPrefixedFileW(name);
+    const nameW = try sliceToPrefixedFileW(null, name);
     return CreateEventExW(attributes, nameW.span().ptr, flags, desired_access);
 }
 @@ -1007,8 +1007,8 @@ pub fn DeleteFile(sub_path_w: []const u16, options: DeleteFileOptions) DeleteFil
 pub const MoveFileError = error{ FileNotFound, AccessDenied, Unexpected };
 pub fn MoveFileEx(old_path: []const u8, new_path: []const u8, flags: DWORD) MoveFileError!void {
-    const old_path_w = try sliceToPrefixedFileW(old_path);
+    const old_path_w = try sliceToPrefixedFileW(null, old_path);
-    const new_path_w = try sliceToPrefixedFileW(new_path);
+    const new_path_w = try sliceToPrefixedFileW(null, new_path);
     return MoveFileExW(old_path_w.span().ptr, new_path_w.span().ptr, flags);
 }
 @@ -1317,7 +1317,7 @@ pub const GetFileAttributesError = error{
 };
 pub fn GetFileAttributes(filename: []const u8) GetFileAttributesError!DWORD {
-    const filename_w = try sliceToPrefixedFileW(filename);
+    const filename_w = try sliceToPrefixedFileW(null, filename);
     return GetFileAttributesW(filename_w.span().ptr);
 }
 @@ -2120,16 +2120,16 @@ pub fn normalizePath(comptime T: type, path: []T) RemoveDotDirsError!usize {
 /// Same as `sliceToPrefixedFileW` but accepts a pointer
 /// to a null-terminated path.
-pub fn cStrToPrefixedFileW(s: [*:0]const u8) !PathSpace {
+pub fn cStrToPrefixedFileW(dir: ?HANDLE, s: [*:0]const u8) !PathSpace {
-    return sliceToPrefixedFileW(mem.sliceTo(s, 0));
+    return sliceToPrefixedFileW(dir, mem.sliceTo(s, 0));
 }
 /// Same as `wToPrefixedFileW` but accepts a UTF-8 encoded path.
-pub fn sliceToPrefixedFileW(path: []const u8) !PathSpace {
+pub fn sliceToPrefixedFileW(dir: ?HANDLE, path: []const u8) !PathSpace {
     var temp_path: PathSpace = undefined;
     temp_path.len = try std.unicode.utf8ToUtf16Le(&temp_path.data, path);
     temp_path.data[temp_path.len] = 0;
-    return wToPrefixedFileW(temp_path.span());
+    return wToPrefixedFileW(dir, temp_path.span());
 }
 /// Converts the `path` to WTF16, null-terminated. If the path contains any
 @@ -2139,11 +2139,11 @@ pub fn sliceToPrefixedFileW(path: []const u8) !PathSpace {
 /// Similar to RtlDosPathNameToNtPathName_U with a few differences:
 /// - Does not allocate on the heap.
 /// - Relative paths are kept as relative unless they contain too many ..
-///   components, in which case they are treated as drive-relative and resolved
+///   components, in which case they are resolved against the `dir` if it
-///   against the CWD.
+///   is non-null, or the CWD if it is null.
 /// - Special case device names like COM1, NUL, etc are not handled specially (TODO)
 /// - . and space are not stripped from the end of relative paths (potential TODO)
-pub fn wToPrefixedFileW(path: [:0]const u16) !PathSpace {
+pub fn wToPrefixedFileW(dir: ?HANDLE, path: [:0]const u16) !PathSpace {
     const nt_prefix = [_]u16{ '\\', '?', '?', '\\' };
     switch (getNamespacePrefix(u16, path)) {
         // TODO: Figure out a way to design an API that can avoid the copy for .nt,
 @@ -2194,8 +2194,7 @@ pub fn wToPrefixedFileW(path: [:0]const u16) !PathSpace {
                     @memcpy(path_space.data[0..path.len], path);
                     // Try to normalize, but if we get too many parent directories,
-                    // then this is effectively a 'drive relative' path, so we need to
+                    // then we need to start over and use RtlGetFullPathName_U instead.
-                    // start over and use RtlGetFullPathName_U instead.
                     path_space.len = normalizePath(u16, path_space.data[0..path.len]) catch |err| switch (err) {
                         error.TooManyParentDirs => break :relative,
                     };
 @@ -2224,8 +2223,37 @@ pub fn wToPrefixedFileW(path: [:0]const u16) !PathSpace {
                 else => nt_prefix.len,
             };
             const buf_len = @as(u32, @intCast(path_space.data.len - path_buf_offset));
+            const path_to_get: [:0]const u16 = path_to_get: {
+                // If dir is null, then we don't need to bother with GetFinalPathNameByHandle because
+                // RtlGetFullPathName_U will resolve relative paths against the CWD for us.
+                if (path_type != .relative or dir == null) {
+                    break :path_to_get path;
+                }
+                // We can also skip GetFinalPathNameByHandle if the handle matches
+                // the handle returned by fs.cwd()
+                if (dir.? == std.fs.cwd().fd) {
+                    break :path_to_get path;
+                }
+                // At this point, we know we have a relative path that had too many
+                // `..` components to be resolved by normalizePath, so we need to
+                // convert it into an absolute path and let RtlGetFullPathName_U
+                // canonicalize it. We do this by getting the path of the `dir`
+                // and appending the relative path to it.
+                var dir_path_buf: [PATH_MAX_WIDE:0]u16 = undefined;
+                const dir_path = try GetFinalPathNameByHandle(dir.?, .{}, &dir_path_buf);
+                if (dir_path.len + 1 + path.len > PATH_MAX_WIDE) {
+                    return error.NameTooLong;
+                }
+                // We don't have to worry about potentially doubling up path separators
+                // here since RtlGetFullPathName_U will handle canonicalizing it.
+                dir_path_buf[dir_path.len] = '\\';
+                @memcpy(dir_path_buf[dir_path.len + 1 ..][0..path.len], path);
+                const full_len = dir_path.len + 1 + path.len;
+                dir_path_buf[full_len] = 0;
+                break :path_to_get dir_path_buf[0..full_len :0];
+            };
             const path_byte_len = ntdll.RtlGetFullPathName_U(
-                path.ptr,
+                path_to_get.ptr,
                 buf_len * 2,
                 path_space.data[path_buf_offset..].ptr,
                 null,

lib/std/os/windows/test.zig+2-2

...	@@ -1118,7 +1118,7 @@ pub const Dir = struct {	...	@@ -1118,7 +1118,7 @@ pub const Dir = struct {
1118	/// Asserts that the path parameter has no null bytes.	1118	/// Asserts that the path parameter has no null bytes.
1119	pub fn openFile(self: Dir, sub_path: []const u8, flags: File.OpenFlags) File.OpenError!File {	1119	pub fn openFile(self: Dir, sub_path: []const u8, flags: File.OpenFlags) File.OpenError!File {
1120	if (builtin.os.tag == .windows) {	1120	if (builtin.os.tag == .windows) {
1121	const path_w = try os.windows.sliceToPrefixedFileW(sub_path);	1121	const path_w = try os.windows.sliceToPrefixedFileW(self.fd, sub_path);
1122	return self.openFileW(path_w.span(), flags);	1122	return self.openFileW(path_w.span(), flags);
1123	}	1123	}
1124	if (builtin.os.tag == .wasi and !builtin.link_libc) {	1124	if (builtin.os.tag == .wasi and !builtin.link_libc) {
...	@@ -1156,7 +1156,7 @@ pub const Dir = struct {	...	@@ -1156,7 +1156,7 @@ pub const Dir = struct {
1156	/// Same as `openFile` but the path parameter is null-terminated.	1156	/// Same as `openFile` but the path parameter is null-terminated.
1157	pub fn openFileZ(self: Dir, sub_path: [*:0]const u8, flags: File.OpenFlags) File.OpenError!File {	1157	pub fn openFileZ(self: Dir, sub_path: [*:0]const u8, flags: File.OpenFlags) File.OpenError!File {
1158	if (builtin.os.tag == .windows) {	1158	if (builtin.os.tag == .windows) {
1159	const path_w = try os.windows.cStrToPrefixedFileW(sub_path);	1159	const path_w = try os.windows.cStrToPrefixedFileW(self.fd, sub_path);
1160	return self.openFileW(path_w.span(), flags);	1160	return self.openFileW(path_w.span(), flags);
1161	}	1161	}
1162		1162
...	@@ -1282,7 +1282,7 @@ pub const Dir = struct {	...	@@ -1282,7 +1282,7 @@ pub const Dir = struct {
1282	/// Asserts that the path parameter has no null bytes.	1282	/// Asserts that the path parameter has no null bytes.
1283	pub fn createFile(self: Dir, sub_path: []const u8, flags: File.CreateFlags) File.OpenError!File {	1283	pub fn createFile(self: Dir, sub_path: []const u8, flags: File.CreateFlags) File.OpenError!File {
1284	if (builtin.os.tag == .windows) {	1284	if (builtin.os.tag == .windows) {
1285	const path_w = try os.windows.sliceToPrefixedFileW(sub_path);	1285	const path_w = try os.windows.sliceToPrefixedFileW(self.fd, sub_path);
1286	return self.createFileW(path_w.span(), flags);	1286	return self.createFileW(path_w.span(), flags);
1287	}	1287	}
1288	if (builtin.os.tag == .wasi and !builtin.link_libc) {	1288	if (builtin.os.tag == .wasi and !builtin.link_libc) {
...	@@ -1323,7 +1323,7 @@ pub const Dir = struct {	...	@@ -1323,7 +1323,7 @@ pub const Dir = struct {
1323	/// Same as `createFile` but the path parameter is null-terminated.	1323	/// Same as `createFile` but the path parameter is null-terminated.
1324	pub fn createFileZ(self: Dir, sub_path_c: [*:0]const u8, flags: File.CreateFlags) File.OpenError!File {	1324	pub fn createFileZ(self: Dir, sub_path_c: [*:0]const u8, flags: File.CreateFlags) File.OpenError!File {
1325	if (builtin.os.tag == .windows) {	1325	if (builtin.os.tag == .windows) {
1326	const path_w = try os.windows.cStrToPrefixedFileW(sub_path_c);	1326	const path_w = try os.windows.cStrToPrefixedFileW(self.fd, sub_path_c);
1327	return self.createFileW(path_w.span(), flags);	1327	return self.createFileW(path_w.span(), flags);
1328	}	1328	}
1329		1329
...	@@ -1513,7 +1513,7 @@ pub const Dir = struct {	...	@@ -1513,7 +1513,7 @@ pub const Dir = struct {
1513	@compileError("realpath is not available on WASI");	1513	@compileError("realpath is not available on WASI");
1514	}	1514	}
1515	if (builtin.os.tag == .windows) {	1515	if (builtin.os.tag == .windows) {
1516	const pathname_w = try os.windows.sliceToPrefixedFileW(pathname);	1516	const pathname_w = try os.windows.sliceToPrefixedFileW(self.fd, pathname);
1517	return self.realpathW(pathname_w.span(), out_buffer);	1517	return self.realpathW(pathname_w.span(), out_buffer);
1518	}	1518	}
1519	const pathname_c = try os.toPosixPath(pathname);	1519	const pathname_c = try os.toPosixPath(pathname);
...	@@ -1524,7 +1524,7 @@ pub const Dir = struct {	...	@@ -1524,7 +1524,7 @@ pub const Dir = struct {
1524	/// See also `Dir.realpath`, `realpathZ`.	1524	/// See also `Dir.realpath`, `realpathZ`.
1525	pub fn realpathZ(self: Dir, pathname: [*:0]const u8, out_buffer: []u8) ![]u8 {	1525	pub fn realpathZ(self: Dir, pathname: [*:0]const u8, out_buffer: []u8) ![]u8 {
1526	if (builtin.os.tag == .windows) {	1526	if (builtin.os.tag == .windows) {
1527	const pathname_w = try os.windows.cStrToPrefixedFileW(pathname);	1527	const pathname_w = try os.windows.cStrToPrefixedFileW(self.fd, pathname);
1528	return self.realpathW(pathname_w.span(), out_buffer);	1528	return self.realpathW(pathname_w.span(), out_buffer);
1529	}	1529	}
1530		1530
...	@@ -1656,7 +1656,7 @@ pub const Dir = struct {	...	@@ -1656,7 +1656,7 @@ pub const Dir = struct {
1656	/// Asserts that the path parameter has no null bytes.	1656	/// Asserts that the path parameter has no null bytes.
1657	pub fn openDir(self: Dir, sub_path: []const u8, args: OpenDirOptions) OpenError!Dir {	1657	pub fn openDir(self: Dir, sub_path: []const u8, args: OpenDirOptions) OpenError!Dir {
1658	if (builtin.os.tag == .windows) {	1658	if (builtin.os.tag == .windows) {
1659	const sub_path_w = try os.windows.sliceToPrefixedFileW(sub_path);	1659	const sub_path_w = try os.windows.sliceToPrefixedFileW(self.fd, sub_path);
1660	return self.openDirW(sub_path_w.span().ptr, args, false);	1660	return self.openDirW(sub_path_w.span().ptr, args, false);
1661	} else if (builtin.os.tag == .wasi and !builtin.link_libc) {	1661	} else if (builtin.os.tag == .wasi and !builtin.link_libc) {
1662	return self.openDirWasi(sub_path, args);	1662	return self.openDirWasi(sub_path, args);
...	@@ -1672,7 +1672,7 @@ pub const Dir = struct {	...	@@ -1672,7 +1672,7 @@ pub const Dir = struct {
1672	/// Asserts that the path parameter has no null bytes.	1672	/// Asserts that the path parameter has no null bytes.
1673	pub fn openIterableDir(self: Dir, sub_path: []const u8, args: OpenDirOptions) OpenError!IterableDir {	1673	pub fn openIterableDir(self: Dir, sub_path: []const u8, args: OpenDirOptions) OpenError!IterableDir {
1674	if (builtin.os.tag == .windows) {	1674	if (builtin.os.tag == .windows) {
1675	const sub_path_w = try os.windows.sliceToPrefixedFileW(sub_path);	1675	const sub_path_w = try os.windows.sliceToPrefixedFileW(self.fd, sub_path);
1676	return IterableDir{ .dir = try self.openDirW(sub_path_w.span().ptr, args, true) };	1676	return IterableDir{ .dir = try self.openDirW(sub_path_w.span().ptr, args, true) };
1677	} else if (builtin.os.tag == .wasi and !builtin.link_libc) {	1677	} else if (builtin.os.tag == .wasi and !builtin.link_libc) {
1678	return IterableDir{ .dir = try self.openDirWasi(sub_path, args) };	1678	return IterableDir{ .dir = try self.openDirWasi(sub_path, args) };
...	@@ -1732,7 +1732,7 @@ pub const Dir = struct {	...	@@ -1732,7 +1732,7 @@ pub const Dir = struct {
1732	/// Same as `openDir` except the parameter is null-terminated.	1732	/// Same as `openDir` except the parameter is null-terminated.
1733	pub fn openDirZ(self: Dir, sub_path_c: [*:0]const u8, args: OpenDirOptions, iterable: bool) OpenError!Dir {	1733	pub fn openDirZ(self: Dir, sub_path_c: [*:0]const u8, args: OpenDirOptions, iterable: bool) OpenError!Dir {
1734	if (builtin.os.tag == .windows) {	1734	if (builtin.os.tag == .windows) {
1735	const sub_path_w = try os.windows.cStrToPrefixedFileW(sub_path_c);	1735	const sub_path_w = try os.windows.cStrToPrefixedFileW(self.fd, sub_path_c);
1736	return self.openDirW(sub_path_w.span().ptr, args, iterable);	1736	return self.openDirW(sub_path_w.span().ptr, args, iterable);
1737	}	1737	}
1738	const symlink_flags: u32 = if (args.no_follow) os.O.NOFOLLOW else 0x0;	1738	const symlink_flags: u32 = if (args.no_follow) os.O.NOFOLLOW else 0x0;
...	@@ -1831,7 +1831,7 @@ pub const Dir = struct {	...	@@ -1831,7 +1831,7 @@ pub const Dir = struct {
1831	/// Asserts that the path parameter has no null bytes.	1831	/// Asserts that the path parameter has no null bytes.
1832	pub fn deleteFile(self: Dir, sub_path: []const u8) DeleteFileError!void {	1832	pub fn deleteFile(self: Dir, sub_path: []const u8) DeleteFileError!void {
1833	if (builtin.os.tag == .windows) {	1833	if (builtin.os.tag == .windows) {
1834	const sub_path_w = try os.windows.sliceToPrefixedFileW(sub_path);	1834	const sub_path_w = try os.windows.sliceToPrefixedFileW(self.fd, sub_path);
1835	return self.deleteFileW(sub_path_w.span());	1835	return self.deleteFileW(sub_path_w.span());
1836	} else if (builtin.os.tag == .wasi and !builtin.link_libc) {	1836	} else if (builtin.os.tag == .wasi and !builtin.link_libc) {
1837	os.unlinkat(self.fd, sub_path, 0) catch \|err\| switch (err) {	1837	os.unlinkat(self.fd, sub_path, 0) catch \|err\| switch (err) {
...	@@ -1894,7 +1894,7 @@ pub const Dir = struct {	...	@@ -1894,7 +1894,7 @@ pub const Dir = struct {
1894	/// Asserts that the path parameter has no null bytes.	1894	/// Asserts that the path parameter has no null bytes.
1895	pub fn deleteDir(self: Dir, sub_path: []const u8) DeleteDirError!void {	1895	pub fn deleteDir(self: Dir, sub_path: []const u8) DeleteDirError!void {
1896	if (builtin.os.tag == .windows) {	1896	if (builtin.os.tag == .windows) {
1897	const sub_path_w = try os.windows.sliceToPrefixedFileW(sub_path);	1897	const sub_path_w = try os.windows.sliceToPrefixedFileW(self.fd, sub_path);
1898	return self.deleteDirW(sub_path_w.span());	1898	return self.deleteDirW(sub_path_w.span());
1899	} else if (builtin.os.tag == .wasi and !builtin.link_libc) {	1899	} else if (builtin.os.tag == .wasi and !builtin.link_libc) {
1900	os.unlinkat(self.fd, sub_path, os.AT.REMOVEDIR) catch \|err\| switch (err) {	1900	os.unlinkat(self.fd, sub_path, os.AT.REMOVEDIR) catch \|err\| switch (err) {
...	@@ -1959,8 +1959,8 @@ pub const Dir = struct {	...	@@ -1959,8 +1959,8 @@ pub const Dir = struct {
1959	return self.symLinkWasi(target_path, sym_link_path, flags);	1959	return self.symLinkWasi(target_path, sym_link_path, flags);
1960	}	1960	}
1961	if (builtin.os.tag == .windows) {	1961	if (builtin.os.tag == .windows) {
1962	const target_path_w = try os.windows.sliceToPrefixedFileW(target_path);	1962	const target_path_w = try os.windows.sliceToPrefixedFileW(self.fd, target_path);
1963	const sym_link_path_w = try os.windows.sliceToPrefixedFileW(sym_link_path);	1963	const sym_link_path_w = try os.windows.sliceToPrefixedFileW(self.fd, sym_link_path);
1964	return self.symLinkW(target_path_w.span(), sym_link_path_w.span(), flags);	1964	return self.symLinkW(target_path_w.span(), sym_link_path_w.span(), flags);
1965	}	1965	}
1966	const target_path_c = try os.toPosixPath(target_path);	1966	const target_path_c = try os.toPosixPath(target_path);
...	@@ -1986,8 +1986,8 @@ pub const Dir = struct {	...	@@ -1986,8 +1986,8 @@ pub const Dir = struct {
1986	flags: SymLinkFlags,	1986	flags: SymLinkFlags,
1987	) !void {	1987	) !void {
1988	if (builtin.os.tag == .windows) {	1988	if (builtin.os.tag == .windows) {
1989	const target_path_w = try os.windows.cStrToPrefixedFileW(target_path_c);	1989	const target_path_w = try os.windows.cStrToPrefixedFileW(self.fd, target_path_c);
1990	const sym_link_path_w = try os.windows.cStrToPrefixedFileW(sym_link_path_c);	1990	const sym_link_path_w = try os.windows.cStrToPrefixedFileW(self.fd, sym_link_path_c);
1991	return self.symLinkW(target_path_w.span(), sym_link_path_w.span(), flags);	1991	return self.symLinkW(target_path_w.span(), sym_link_path_w.span(), flags);
1992	}	1992	}
1993	return os.symlinkatZ(target_path_c, self.fd, sym_link_path_c);	1993	return os.symlinkatZ(target_path_c, self.fd, sym_link_path_c);
...	@@ -2012,7 +2012,7 @@ pub const Dir = struct {	...	@@ -2012,7 +2012,7 @@ pub const Dir = struct {
2012	return self.readLinkWasi(sub_path, buffer);	2012	return self.readLinkWasi(sub_path, buffer);
2013	}	2013	}
2014	if (builtin.os.tag == .windows) {	2014	if (builtin.os.tag == .windows) {
2015	const sub_path_w = try os.windows.sliceToPrefixedFileW(sub_path);	2015	const sub_path_w = try os.windows.sliceToPrefixedFileW(self.fd, sub_path);
2016	return self.readLinkW(sub_path_w.span(), buffer);	2016	return self.readLinkW(sub_path_w.span(), buffer);
2017	}	2017	}
2018	const sub_path_c = try os.toPosixPath(sub_path);	2018	const sub_path_c = try os.toPosixPath(sub_path);
...	@@ -2027,7 +2027,7 @@ pub const Dir = struct {	...	@@ -2027,7 +2027,7 @@ pub const Dir = struct {
2027	/// Same as `readLink`, except the `pathname` parameter is null-terminated.	2027	/// Same as `readLink`, except the `pathname` parameter is null-terminated.
2028	pub fn readLinkZ(self: Dir, sub_path_c: [*:0]const u8, buffer: []u8) ![]u8 {	2028	pub fn readLinkZ(self: Dir, sub_path_c: [*:0]const u8, buffer: []u8) ![]u8 {
2029	if (builtin.os.tag == .windows) {	2029	if (builtin.os.tag == .windows) {
2030	const sub_path_w = try os.windows.cStrToPrefixedFileW(sub_path_c);	2030	const sub_path_w = try os.windows.cStrToPrefixedFileW(self.fd, sub_path_c);
2031	return self.readLinkW(sub_path_w.span(), buffer);	2031	return self.readLinkW(sub_path_w.span(), buffer);
2032	}	2032	}
2033	return os.readlinkatZ(self.fd, sub_path_c, buffer);	2033	return os.readlinkatZ(self.fd, sub_path_c, buffer);
...	@@ -2501,7 +2501,10 @@ pub const Dir = struct {	...	@@ -2501,7 +2501,10 @@ pub const Dir = struct {
2501	/// open it and handle the error for file not found.	2501	/// open it and handle the error for file not found.
2502	pub fn access(self: Dir, sub_path: []const u8, flags: File.OpenFlags) AccessError!void {	2502	pub fn access(self: Dir, sub_path: []const u8, flags: File.OpenFlags) AccessError!void {
2503	if (builtin.os.tag == .windows) {	2503	if (builtin.os.tag == .windows) {
2504	const sub_path_w = try os.windows.sliceToPrefixedFileW(sub_path);	2504	const sub_path_w = os.windows.sliceToPrefixedFileW(self.fd, sub_path) catch \|err\| switch (err) {
		2505	error.AccessDenied => return error.PermissionDenied,
		2506	else => \|e\| return e,
		2507	};
2505	return self.accessW(sub_path_w.span().ptr, flags);	2508	return self.accessW(sub_path_w.span().ptr, flags);
2506	}	2509	}
2507	const path_c = try os.toPosixPath(sub_path);	2510	const path_c = try os.toPosixPath(sub_path);
...	@@ -2511,7 +2514,10 @@ pub const Dir = struct {	...	@@ -2511,7 +2514,10 @@ pub const Dir = struct {
2511	/// Same as `access` except the path parameter is null-terminated.	2514	/// Same as `access` except the path parameter is null-terminated.
2512	pub fn accessZ(self: Dir, sub_path: [*:0]const u8, flags: File.OpenFlags) AccessError!void {	2515	pub fn accessZ(self: Dir, sub_path: [*:0]const u8, flags: File.OpenFlags) AccessError!void {
2513	if (builtin.os.tag == .windows) {	2516	if (builtin.os.tag == .windows) {
2514	const sub_path_w = try os.windows.cStrToPrefixedFileW(sub_path);	2517	const sub_path_w = os.windows.cStrToPrefixedFileW(self.fd, sub_path) catch \|err\| switch (err) {
		2518	error.AccessDenied => return error.PermissionDenied,
		2519	else => \|e\| return e,
		2520	};
2515	return self.accessW(sub_path_w.span().ptr, flags);	2521	return self.accessW(sub_path_w.span().ptr, flags);
2516	}	2522	}
2517	const os_mode = switch (flags.mode) {	2523	const os_mode = switch (flags.mode) {
...	@@ -2894,8 +2900,8 @@ pub fn symLinkAbsolute(target_path: []const u8, sym_link_path: []const u8, flags	...	@@ -2894,8 +2900,8 @@ pub fn symLinkAbsolute(target_path: []const u8, sym_link_path: []const u8, flags
2894	assert(path.isAbsolute(target_path));	2900	assert(path.isAbsolute(target_path));
2895	assert(path.isAbsolute(sym_link_path));	2901	assert(path.isAbsolute(sym_link_path));
2896	if (builtin.os.tag == .windows) {	2902	if (builtin.os.tag == .windows) {
2897	const target_path_w = try os.windows.sliceToPrefixedFileW(target_path);	2903	const target_path_w = try os.windows.sliceToPrefixedFileW(null, target_path);
2898	const sym_link_path_w = try os.windows.sliceToPrefixedFileW(sym_link_path);	2904	const sym_link_path_w = try os.windows.sliceToPrefixedFileW(null, sym_link_path);
2899	return os.windows.CreateSymbolicLink(null, sym_link_path_w.span(), target_path_w.span(), flags.is_directory);	2905	return os.windows.CreateSymbolicLink(null, sym_link_path_w.span(), target_path_w.span(), flags.is_directory);
2900	}	2906	}
2901	return os.symlink(target_path, sym_link_path);	2907	return os.symlink(target_path, sym_link_path);
...	@@ -2945,7 +2951,7 @@ pub fn openSelfExe(flags: File.OpenFlags) OpenSelfExeError!File {	...	@@ -2945,7 +2951,7 @@ pub fn openSelfExe(flags: File.OpenFlags) OpenSelfExeError!File {
2945	}	2951	}
2946	if (builtin.os.tag == .windows) {	2952	if (builtin.os.tag == .windows) {
2947	const wide_slice = selfExePathW();	2953	const wide_slice = selfExePathW();
2948	const prefixed_path_w = try os.windows.wToPrefixedFileW(wide_slice);	2954	const prefixed_path_w = try os.windows.wToPrefixedFileW(null, wide_slice);
2949	return cwd().openFileW(prefixed_path_w.span(), flags);	2955	return cwd().openFileW(prefixed_path_w.span(), flags);
2950	}	2956	}
2951	// Use of MAX_PATH_BYTES here is valid as the resulting path is immediately	2957	// Use of MAX_PATH_BYTES here is valid as the resulting path is immediately

...	@@ -28,7 +28,7 @@ fn RtlDosPathNameToNtPathName_U(path: [:0]const u16) !windows.PathSpace {	...	@@ -28,7 +28,7 @@ fn RtlDosPathNameToNtPathName_U(path: [:0]const u16) !windows.PathSpace {
28	fn testToPrefixedFileNoOracle(comptime path: []const u8, comptime expected_path: []const u8) !void {	28	fn testToPrefixedFileNoOracle(comptime path: []const u8, comptime expected_path: []const u8) !void {
29	const path_utf16 = std.unicode.utf8ToUtf16LeStringLiteral(path);	29	const path_utf16 = std.unicode.utf8ToUtf16LeStringLiteral(path);
30	const expected_path_utf16 = std.unicode.utf8ToUtf16LeStringLiteral(expected_path);	30	const expected_path_utf16 = std.unicode.utf8ToUtf16LeStringLiteral(expected_path);
31	const actual_path = try windows.wToPrefixedFileW(path_utf16);	31	const actual_path = try windows.wToPrefixedFileW(null, path_utf16);
32	std.testing.expectEqualSlices(u16, expected_path_utf16, actual_path.span()) catch \|e\| {	32	std.testing.expectEqualSlices(u16, expected_path_utf16, actual_path.span()) catch \|e\| {
33	std.debug.print("got '{s}', expected '{s}'\n", .{ std.unicode.fmtUtf16le(actual_path.span()), std.unicode.fmtUtf16le(expected_path_utf16) });	33	std.debug.print("got '{s}', expected '{s}'\n", .{ std.unicode.fmtUtf16le(actual_path.span()), std.unicode.fmtUtf16le(expected_path_utf16) });
34	return e;	34	return e;
...	@@ -45,7 +45,7 @@ fn testToPrefixedFileWithOracle(comptime path: []const u8, comptime expected_pat	...	@@ -45,7 +45,7 @@ fn testToPrefixedFileWithOracle(comptime path: []const u8, comptime expected_pat
45	/// Test that the Zig conversion matches the conversion that RtlDosPathNameToNtPathName_U does.	45	/// Test that the Zig conversion matches the conversion that RtlDosPathNameToNtPathName_U does.
46	fn testToPrefixedFileOnlyOracle(comptime path: []const u8) !void {	46	fn testToPrefixedFileOnlyOracle(comptime path: []const u8) !void {
47	const path_utf16 = std.unicode.utf8ToUtf16LeStringLiteral(path);	47	const path_utf16 = std.unicode.utf8ToUtf16LeStringLiteral(path);
48	const zig_result = try windows.wToPrefixedFileW(path_utf16);	48	const zig_result = try windows.wToPrefixedFileW(null, path_utf16);
49	const win32_api_result = try RtlDosPathNameToNtPathName_U(path_utf16);	49	const win32_api_result = try RtlDosPathNameToNtPathName_U(path_utf16);
50	std.testing.expectEqualSlices(u16, win32_api_result.span(), zig_result.span()) catch \|e\| {	50	std.testing.expectEqualSlices(u16, win32_api_result.span(), zig_result.span()) catch \|e\| {
51	std.debug.print("got '{s}', expected '{s}'\n", .{ std.unicode.fmtUtf16le(zig_result.span()), std.unicode.fmtUtf16le(win32_api_result.span()) });	51	std.debug.print("got '{s}', expected '{s}'\n", .{ std.unicode.fmtUtf16le(zig_result.span()), std.unicode.fmtUtf16le(win32_api_result.span()) });