mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-06 14:23:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

fs.selfExePath: Make the Windows implementation follow symlinks

Browse Source 
Before, selfExePath would be the path of the symlink on Windows instead of the path of what the symlink points to.

This deprecates fs.selfExePathW since it does not provide a separate use-case over selfExePath (before, the W version could return [:0]u16 directly)

Fixes #16670
This commit is contained in:
Ryan Liptak 2023-08-19 12:48:51 -07:00
parent 7ef1eb1c27
commit 2c2ecd624a
1 changed files with 16 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
lib/std/fs.zig
View File

@ -2949,8 +2949,12 @@ pub fn openSelfExe(flags: File.OpenFlags) OpenSelfExeError!File {
return openFileAbsoluteZ("/proc/self/exe", flags); return openFileAbsoluteZ("/proc/self/exe", flags);
} }
if (builtin.os.tag == .windows) { if (builtin.os.tag == .windows) {
const wide_slice = selfExePathW(); // If ImagePathName is a symlink, then it will contain the path of the symlink,
const prefixed_path_w = try os.windows.wToPrefixedFileW(null, wide_slice); // not the path that the symlink points to. However, because we are opening
// the file, we can let the openFileW call follow the symlink for us.
const image_path_unicode_string = &os.windows.peb().ProcessParameters.ImagePathName;
const image_path_name = image_path_unicode_string.Buffer[0 .. image_path_unicode_string.Length / 2 :0];
const prefixed_path_w = try os.windows.wToPrefixedFileW(null, image_path_name);
return cwd().openFileW(prefixed_path_w.span(), flags); return cwd().openFileW(prefixed_path_w.span(), flags);
} }
// Use of MAX_PATH_BYTES here is valid as the resulting path is immediately // Use of MAX_PATH_BYTES here is valid as the resulting path is immediately
@ -2977,7 +2981,7 @@ pub fn selfExePathAlloc(allocator: Allocator) ![]u8 {
return allocator.dupe(u8, try selfExePath(&buf)); return allocator.dupe(u8, try selfExePath(&buf));
} }
/// Get the path to the current executable. /// Get the path to the current executable. Follows symlinks.
/// If you only need the directory, use selfExeDirPath. /// If you only need the directory, use selfExeDirPath.
/// If you only want an open file handle, use openSelfExe. /// If you only want an open file handle, use openSelfExe.
/// This function may return an error if the current executable /// This function may return an error if the current executable
@ -3060,21 +3064,21 @@ pub fn selfExePath(out_buffer: []u8) SelfExePathError![]u8 {
return error.FileNotFound; return error.FileNotFound;
}, },
.windows => { .windows => {
const utf16le_slice = selfExePathW(); const image_path_unicode_string = &os.windows.peb().ProcessParameters.ImagePathName;
// Trust that Windows gives us valid UTF-16LE. const image_path_name = image_path_unicode_string.Buffer[0 .. image_path_unicode_string.Length / 2 :0];
const end_index = std.unicode.utf16leToUtf8(out_buffer, utf16le_slice) catch unreachable;
return out_buffer[0..end_index]; // If ImagePathName is a symlink, then it will contain the path of the
// symlink, not the path that the symlink points to. We want the path
// that the symlink points to, though, so we need to get the realpath.
const pathname_w = try os.windows.wToPrefixedFileW(null, image_path_name);
return std.fs.cwd().realpathW(pathname_w.span(), out_buffer);
}, },
.wasi => @compileError("std.fs.selfExePath not supported for WASI. Use std.fs.selfExePathAlloc instead."), .wasi => @compileError("std.fs.selfExePath not supported for WASI. Use std.fs.selfExePathAlloc instead."),
else => @compileError("std.fs.selfExePath not supported for this target"), else => @compileError("std.fs.selfExePath not supported for this target"),
} }
} }
/// The result is UTF16LE-encoded. pub const selfExePathW = @compileError("deprecated; use selfExePath instead");
pub fn selfExePathW() [:0]const u16 {
const image_path_name = &os.windows.peb().ProcessParameters.ImagePathName;
return image_path_name.Buffer[0 .. image_path_name.Length / 2 :0];
}
/// `selfExeDirPath` except allocates the result on the heap. /// `selfExeDirPath` except allocates the result on the heap.
/// Caller owns returned memory. /// Caller owns returned memory.