std.os.windows.GetFinalPathNameByHandle: replace kernel32 by ntdll call

Removes the call to kernel32.GetFinalPathNameByHandleW in favor of NtQueryObject, which means we can reuse the other codepath's logic for DOS naming. Also cleans up the test case.

Author: rohlem

lib/std/os/windows.zig

@@ -1033,67 +1033,53 @@ pub fn GetFinalPathNameByHandle(
     out_buffer: []u16,
 ) GetFinalPathNameByHandleError![]u16 {
 
-    if((comptime (targetVersionIsAtLeast(WindowsVersion.win10_rs4) != true)) //need explicit comptime, because error returns affect return type
-       and !runtimeVersionIsAtLeast(WindowsVersion.win10_rs4)){
-        // TODO: directly replace/emulate QueryInformationFile of .FileNormalizedNameInformation
-        // with ntdll instead of calling into kernel32
-        // (probably using some less-powerful query and looping over path segments)
-        const flags: DWORD = FILE_NAME_NORMALIZED | switch(fmt.volume_name){
-            .Dos => @as(DWORD, VOLUME_NAME_DOS),
-            .Nt => @as(DWORD, VOLUME_NAME_NT),
-        };
-        const rc = kernel32.GetFinalPathNameByHandleW(hFile, out_buffer.ptr, @intCast(u32, out_buffer.len), flags);
-        if (rc == 0) {
-            switch (kernel32.GetLastError()) {
-                .FILE_NOT_FOUND => return error.FileNotFound,
-                .PATH_NOT_FOUND => return error.FileNotFound,
-                .NOT_ENOUGH_MEMORY => return error.SystemResources,
-                .FILENAME_EXCED_RANGE => return error.NameTooLong,
-                .ACCESS_DENIED => return error.AccessDenied, //can happen in SMB sub-queries for parent path segments
-                .INVALID_PARAMETER => unreachable,
-                else => |err| return unexpectedError(err),
-            }
-        }
-
-        if(rc > out_buffer.len) return error.NameTooLong; //rc = length of string INCLUDING null terminator (unlike in case of success)
-        //in case of success, rc = length of string EXCLUDING null terminator
-        std.debug.assert(rc < out_buffer.len); //this would mean the length we provided was enough, but GetFinalPathNameByHandleW thinks it wasn't
-
-        switch(fmt.volume_name){
-            .Dos => {
-                const expected_prefix = [_]u16{'\\', '\\', '?', '\\'};
-                assert(std.mem.eql(u16, expected_prefix[0..], out_buffer[0..expected_prefix.len]));
-                return out_buffer[expected_prefix.len..rc:0];
-            },
-            .Nt => return out_buffer[0..rc:0], //no prefix here, which isn't mentioned in documentation
-        }
-    }
-
-    // Get normalized path; doesn't include volume name though.
     var path_buffer: [@sizeOf(FILE_NAME_INFORMATION) + PATH_MAX_WIDE * 2]u8 align(@alignOf(FILE_NAME_INFORMATION)) = undefined;
-    try QueryInformationFile(hFile, .FileNormalizedNameInformation, path_buffer[0..]);
-
-    // Get NT volume name.
     var volume_buffer: [@sizeOf(FILE_NAME_INFORMATION) + MAX_PATH]u8 align(@alignOf(FILE_NAME_INFORMATION)) = undefined; // MAX_PATH bytes should be enough since it's Windows-defined name
-    try QueryInformationFile(hFile, .FileVolumeNameInformation, volume_buffer[0..]);
 
-    const file_name = @ptrCast(*const FILE_NAME_INFORMATION, &path_buffer[0]);
-    const file_name_u16 = @ptrCast([*]const u16, &file_name.FileName[0])[0 .. file_name.FileNameLength / 2];
+    var file_name_u16: []const u16 = undefined;
+    var volume_name_u16: []const u16 = undefined;
+    if((comptime (targetVersionIsAtLeast(WindowsVersion.win10_rs4) != true)) //need explicit comptime, because error returns affect return type
+       and !runtimeVersionIsAtLeast(WindowsVersion.win10_rs4)){
+        const final_path = try QueryObjectName(hFile, out_buffer, null);
 
-    const volume_name = @ptrCast(*const FILE_NAME_INFORMATION, &volume_buffer[0]);
+        if(fmt.volume_name == .Nt){
+            return final_path; //we can directly return the slice we received
+        }
 
-    switch (fmt.volume_name) {
-        .Nt => {
+        //otherwise we need to parse the string for volume path for the .Dos logic below to work
+        const expected_prefix = std.unicode.utf8ToUtf16LeStringLiteral("\\Device\\");
+        std.debug.assert(std.mem.eql(u16, expected_prefix, final_path[0..expected_prefix.len]));
+        const index = std.mem.indexOfPos(u16, final_path, expected_prefix.len, &[_]u16{'\\'}) orelse unreachable;
+        volume_name_u16 = final_path[0..index];
+        file_name_u16 = final_path[index..];
+
+        //fallthrough for fmt.volume_name != .Nt
+    }else{
+        // Get normalized path; doesn't include volume name though.
+        try QueryInformationFile(hFile, .FileNormalizedNameInformation, path_buffer[0..]);
+        const file_name = @ptrCast(*const FILE_NAME_INFORMATION, &path_buffer[0]);
+        file_name_u16 = @ptrCast([*]const u16, &file_name.FileName[0])[0 .. @divExact(file_name.FileNameLength, 2)];
+
+        // Get NT volume name.
+        try QueryInformationFile(hFile, .FileVolumeNameInformation, volume_buffer[0..]);
+        const volume_name_info = @ptrCast(*const FILE_NAME_INFORMATION, &volume_buffer[0]);
+        volume_name_u16 = @ptrCast([*]const u16, &volume_name_info.FileName[0])[0 .. @divExact(volume_name_info.FileNameLength, 2)];
+
+        if(fmt.volume_name == .Nt){
             // Nothing to do, we simply copy the bytes to the user-provided buffer.
-            const volume_name_u16 = @ptrCast([*]const u16, &volume_name.FileName[0])[0 .. volume_name.FileNameLength / 2];
 
             if (out_buffer.len < volume_name_u16.len + file_name_u16.len) return error.NameTooLong;
 
             std.mem.copy(u16, out_buffer[0..], volume_name_u16);
             std.mem.copy(u16, out_buffer[volume_name_u16.len..], file_name_u16);
 
             return out_buffer[0 .. volume_name_u16.len + file_name_u16.len];
-        },
+        }
+        //fallthrough for fmt.volume_name != .Nt
+    }
+
+    switch (fmt.volume_name) {
+        .Nt => unreachable, //handled above
         .Dos => {
             // Get DOS volume name. DOS volume names are actually symbolic link objects to the
             // actual NT volume. For example:
@@ -1127,8 +1113,8 @@ pub fn GetFinalPathNameByHandle(
 
             var input_struct = @ptrCast(*MOUNTMGR_MOUNT_POINT, &input_buf[0]);
             input_struct.DeviceNameOffset = @sizeOf(MOUNTMGR_MOUNT_POINT);
-            input_struct.DeviceNameLength = @intCast(USHORT, volume_name.FileNameLength);
-            @memcpy(input_buf[@sizeOf(MOUNTMGR_MOUNT_POINT)..], @ptrCast([*]const u8, &volume_name.FileName[0]), volume_name.FileNameLength);
+            input_struct.DeviceNameLength = @intCast(USHORT, volume_name_u16.len * 2);
+            @memcpy(input_buf[@sizeOf(MOUNTMGR_MOUNT_POINT)..], @ptrCast([*]const u8, volume_name_u16.ptr), volume_name_u16.len * 2);
 
             DeviceIoControl(mgmt_handle, IOCTL_MOUNTMGR_QUERY_POINTS, input_buf[0..], output_buf[0..]) catch |err| switch (err) {
                 error.AccessDenied => unreachable,
@@ -1185,42 +1171,36 @@ test "GetFinalPathNameByHandle" {
         return;
 
     const S = struct {fn check(file: std.fs.File, buffer: anytype, fmt: std.os.windows.GetFinalPathNameByHandleFormat) !usize {
-        const real = try std.os.windows.GetFinalPathNameByHandle(file.handle, .{.volume_name = .Dos}, buffer[0..]);
-        //const utf8_real = try std.unicode.utf16leToUtf8Alloc(std.testing.allocator, real);
-        //defer std.testing.allocator.free(utf8_real);
-        //std.debug.print("real path: {}\n", .{utf8_real});
-        const offset = @divExact((@ptrToInt(real.ptr) - @ptrToInt(@ptrCast([*]u16,buffer))), 2);
+        const real = try std.os.windows.GetFinalPathNameByHandle(file.handle, fmt, buffer[0..]);
+        const offset = @divExact((@ptrToInt(real.ptr) - @ptrToInt(@ptrCast([*]u16, buffer))), 2);
         return real.len + offset;
     }};
 
-    const selfExeFile: std.fs.File = try std.fs.openSelfExe(.{}); //any file would do
-
+    const file: std.fs.File = try std.fs.openSelfExe(.{}); //any file would do
+    defer file.close();
     var buffer = std.mem.zeroes([1<<10]u16); //make this big enough for the test runner exe path
 
     //check with sufficient size
-    const dos_length = try S.check(selfExeFile, buffer[0..], .{.volume_name = .Dos});
-    const nt_length = try S.check(selfExeFile, buffer[0..], .{.volume_name = .Nt});
+    const nt_length = try S.check(file, buffer[0..], .{.volume_name = .Nt});
+    const dos_length = try S.check(file, buffer[0..], .{.volume_name = .Dos});
 
     //check with size insufficient by more than 1 character: always errors
-    var err_count: u2 = 0;
-    _ = S.check(selfExeFile, buffer[0..dos_length-1], .{.volume_name = .Dos})
-        catch |e| switch(e) {error.NameTooLong => {err_count += 1;}, else => unreachable};
-    _ = S.check(selfExeFile, buffer[0..nt_length-1], .{.volume_name = .Nt})
-        catch |e| switch(e) {error.NameTooLong => {err_count += 1;}, else => unreachable};
-    std.testing.expectEqual(@as(u2, 2), err_count);
-
-    //check with size insufficient for null terminator: errors only on kernel32 path
-    err_count = 0;
-    _ = S.check(selfExeFile, buffer[0..dos_length], .{.volume_name = .Dos})
-        catch |e| switch(e) {error.NameTooLong => {err_count += 1;}, else => unreachable};
-    _ = S.check(selfExeFile, buffer[0..nt_length], .{.volume_name = .Nt})
-        catch |e| switch(e) {error.NameTooLong => {err_count += 1;}, else => unreachable};
-    const expect_no_errors = std.os.windows.runtimeVersionIsAtLeast(std.os.windows.WindowsVersion.win10_rs4);
-    std.testing.expectEqual(if(expect_no_errors) @as(u2, 0) else @as(u2, 2), err_count);
+    std.testing.expect(null == S.check(file, buffer[0..nt_length-1], .{.volume_name = .Nt})
+        catch |e| switch(e) {error.NameTooLong => null, else => unreachable});
+    std.testing.expect(null == S.check(file, buffer[0..dos_length-1], .{.volume_name = .Dos})
+        catch |e| switch(e) {error.NameTooLong => null, else => unreachable});
+
+    //check with size insufficient for null terminator: errors only on NtQueryObject path
+    const queryObjectPath = !std.os.windows.runtimeVersionIsAtLeast(std.os.windows.WindowsVersion.win10_rs4);
+    std.testing.expect(queryObjectPath == (null == S.check(file, buffer[0..nt_length], .{.volume_name = .Nt})
+        catch |e| switch(e) {error.NameTooLong => null, else => unreachable}));
+    std.testing.expect(queryObjectPath == (null == S.check(file, buffer[0..dos_length], .{.volume_name = .Dos})
+        catch |e| switch(e) {error.NameTooLong => null, else => unreachable}));
 
     //check with exactly-sufficient size
-    _ = try S.check(selfExeFile, buffer[0..dos_length+1], .{.volume_name = .Dos});
-    _ = try S.check(selfExeFile, buffer[0..nt_length+1], .{.volume_name = .Nt});
+    const sufficient_dos_length = if(queryObjectPath) nt_length+1 else dos_length+1;
+    _ = try S.check(file, buffer[0..nt_length+1], .{.volume_name = .Nt});
+    _ = try S.check(file, buffer[0..sufficient_dos_length], .{.volume_name = .Dos});
 }
 
 pub const QueryInformationFileError = error{Unexpected};