| ... | @@ -897,30 +897,156 @@ pub fn SetFilePointerEx_CURRENT_get(handle: HANDLE) SetFilePointerError!u64 { | ... | @@ -897,30 +897,156 @@ pub fn SetFilePointerEx_CURRENT_get(handle: HANDLE) SetFilePointerError!u64 { |
| 897 | } | 897 | } |
| 898 | | 898 | |
| 899 | pub const GetFinalPathNameByHandleError = error{ | 899 | pub const GetFinalPathNameByHandleError = error{ |
| | 900 | BadPathName, |
| 900 | FileNotFound, | 901 | FileNotFound, |
| 901 | SystemResources, | | |
| 902 | NameTooLong, | 902 | NameTooLong, |
| 903 | Unexpected, | 903 | Unexpected, |
| 904 | }; | 904 | }; |
| 905 | | 905 | |
| 906 | pub fn GetFinalPathNameByHandleW( | 906 | /// Specifies how to format volume path in the result of `GetFinalPathNameByHandle`. |
| | 907 | /// Defaults to DOS volume names. |
| | 908 | pub const GetFinalPathNameByHandleFormat = struct { |
| | 909 | volume_name: enum { |
| | 910 | /// Format as DOS volume name |
| | 911 | Dos, |
| | 912 | /// Format as NT volume name |
| | 913 | Nt, |
| | 914 | } = .Dos, |
| | 915 | }; |
| | 916 | |
| | 917 | /// Returns canonical (normalized) path of handle. |
| | 918 | /// Use `GetFinalPathNameByHandleFormat` to specify whether the path is meant to include |
| | 919 | /// NT or DOS volume name (e.g., `\Device\HarddiskVolume0\foo.txt` versus `C:\foo.txt`). |
| | 920 | /// If DOS volume name format is selected, note that this function does *not* prepend |
| | 921 | /// `\\?\` prefix to the resultant path. |
| | 922 | pub fn GetFinalPathNameByHandle( |
| 907 | hFile: HANDLE, | 923 | hFile: HANDLE, |
| 908 | buf_ptr: [*]u16, | 924 | fmt: GetFinalPathNameByHandleFormat, |
| 909 | buf_len: DWORD, | 925 | out_buffer: []u16, |
| 910 | flags: DWORD, | 926 | ) GetFinalPathNameByHandleError![]u16 { |
| 911 | ) GetFinalPathNameByHandleError![:0]u16 { | 927 | // Get normalized path; doesn't include volume name though. |
| 912 | const rc = kernel32.GetFinalPathNameByHandleW(hFile, buf_ptr, buf_len, flags); | 928 | var path_buffer: [@sizeOf(FILE_NAME_INFORMATION) + PATH_MAX_WIDE * 2]u8 align(@alignOf(FILE_NAME_INFORMATION)) = undefined; |
| 913 | if (rc == 0) { | 929 | try QueryInformationFile(hFile, .FileNormalizedNameInformation, path_buffer[0..]); |
| 914 | switch (kernel32.GetLastError()) { | 930 | |
| 915 | .FILE_NOT_FOUND => return error.FileNotFound, | 931 | // Get NT volume name. |
| 916 | .PATH_NOT_FOUND => return error.FileNotFound, | 932 | 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 |
| 917 | .NOT_ENOUGH_MEMORY => return error.SystemResources, | 933 | try QueryInformationFile(hFile, .FileVolumeNameInformation, volume_buffer[0..]); |
| 918 | .FILENAME_EXCED_RANGE => return error.NameTooLong, | 934 | |
| 919 | .INVALID_PARAMETER => unreachable, | 935 | const file_name = @ptrCast(*const FILE_NAME_INFORMATION, &path_buffer[0]); |
| 920 | else => |err| return unexpectedError(err), | 936 | const file_name_u16 = @ptrCast([*]const u16, &file_name.FileName[0])[0 .. file_name.FileNameLength / 2]; |
| 921 | } | 937 | |
| | 938 | const volume_name = @ptrCast(*const FILE_NAME_INFORMATION, &volume_buffer[0]); |
| | 939 | |
| | 940 | switch (fmt.volume_name) { |
| | 941 | .Nt => { |
| | 942 | // Nothing to do, we simply copy the bytes to the user-provided buffer. |
| | 943 | const volume_name_u16 = @ptrCast([*]const u16, &volume_name.FileName[0])[0 .. volume_name.FileNameLength / 2]; |
| | 944 | |
| | 945 | if (out_buffer.len < volume_name_u16.len + file_name_u16.len) return error.NameTooLong; |
| | 946 | |
| | 947 | std.mem.copy(u16, out_buffer[0..], volume_name_u16); |
| | 948 | std.mem.copy(u16, out_buffer[volume_name_u16.len..], file_name_u16); |
| | 949 | |
| | 950 | return out_buffer[0 .. volume_name_u16.len + file_name_u16.len]; |
| | 951 | }, |
| | 952 | .Dos => { |
| | 953 | // Get DOS volume name. DOS volume names are actually symbolic link objects to the |
| | 954 | // actual NT volume. For example: |
| | 955 | // (NT) \Device\HarddiskVolume4 => (DOS) \DosDevices\C: == (DOS) C: |
| | 956 | const MIN_SIZE = @sizeOf(MOUNTMGR_MOUNT_POINT) + MAX_PATH; |
| | 957 | // We initialize the input buffer to all zeros for convenience since |
| | 958 | // `DeviceIoControl` with `IOCTL_MOUNTMGR_QUERY_POINTS` expects this. |
| | 959 | var input_buf: [MIN_SIZE]u8 align(@alignOf(MOUNTMGR_MOUNT_POINT)) = [_]u8{0} ** MIN_SIZE; |
| | 960 | var output_buf: [MIN_SIZE * 4]u8 align(@alignOf(MOUNTMGR_MOUNT_POINTS)) = undefined; |
| | 961 | |
| | 962 | // This surprising path is a filesystem path to the mount manager on Windows. |
| | 963 | // Source: https://stackoverflow.com/questions/3012828/using-ioctl-mountmgr-query-points |
| | 964 | const mgmt_path = "\\MountPointManager"; |
| | 965 | const mgmt_path_u16 = sliceToPrefixedFileW(mgmt_path) catch unreachable; |
| | 966 | const mgmt_handle = OpenFile(mgmt_path_u16.span(), .{ |
| | 967 | .access_mask = SYNCHRONIZE, |
| | 968 | .share_access = FILE_SHARE_READ | FILE_SHARE_WRITE, |
| | 969 | .creation = FILE_OPEN, |
| | 970 | .io_mode = .blocking, |
| | 971 | }) catch |err| switch (err) { |
| | 972 | error.IsDir => unreachable, |
| | 973 | error.NotDir => unreachable, |
| | 974 | error.NoDevice => unreachable, |
| | 975 | error.AccessDenied => unreachable, |
| | 976 | error.PipeBusy => unreachable, |
| | 977 | error.PathAlreadyExists => unreachable, |
| | 978 | error.WouldBlock => unreachable, |
| | 979 | else => |e| return e, |
| | 980 | }; |
| | 981 | defer CloseHandle(mgmt_handle); |
| | 982 | |
| | 983 | var input_struct = @ptrCast(*MOUNTMGR_MOUNT_POINT, &input_buf[0]); |
| | 984 | input_struct.DeviceNameOffset = @sizeOf(MOUNTMGR_MOUNT_POINT); |
| | 985 | input_struct.DeviceNameLength = @intCast(USHORT, volume_name.FileNameLength); |
| | 986 | @memcpy(input_buf[@sizeOf(MOUNTMGR_MOUNT_POINT)..], @ptrCast([*]const u8, &volume_name.FileName[0]), volume_name.FileNameLength); |
| | 987 | |
| | 988 | try DeviceIoControl(mgmt_handle, IOCTL_MOUNTMGR_QUERY_POINTS, input_buf[0..], output_buf[0..]); |
| | 989 | const mount_points_struct = @ptrCast(*const MOUNTMGR_MOUNT_POINTS, &output_buf[0]); |
| | 990 | |
| | 991 | const mount_points = @ptrCast( |
| | 992 | [*]const MOUNTMGR_MOUNT_POINT, |
| | 993 | &mount_points_struct.MountPoints[0], |
| | 994 | )[0..mount_points_struct.NumberOfMountPoints]; |
| | 995 | |
| | 996 | var found: bool = false; |
| | 997 | for (mount_points) |mount_point| { |
| | 998 | const symlink = @ptrCast( |
| | 999 | [*]const u16, |
| | 1000 | @alignCast(@alignOf(u16), &output_buf[mount_point.SymbolicLinkNameOffset]), |
| | 1001 | )[0 .. mount_point.SymbolicLinkNameLength / 2]; |
| | 1002 | |
| | 1003 | // Look for `\DosDevices\` prefix. We don't really care if there are more than one symlinks |
| | 1004 | // with traditional DOS drive letters, so pick the first one available. |
| | 1005 | const prefix_u8 = "\\DosDevices\\"; |
| | 1006 | var prefix_buf_u16: [prefix_u8.len]u16 = undefined; |
| | 1007 | const prefix_len_u16 = std.unicode.utf8ToUtf16Le(prefix_buf_u16[0..], prefix_u8[0..]) catch unreachable; |
| | 1008 | const prefix = prefix_buf_u16[0..prefix_len_u16]; |
| | 1009 | |
| | 1010 | if (std.mem.startsWith(u16, symlink, prefix)) { |
| | 1011 | const drive_letter = symlink[prefix.len..]; |
| | 1012 | |
| | 1013 | if (out_buffer.len < drive_letter.len + file_name_u16.len) return error.NameTooLong; |
| | 1014 | |
| | 1015 | std.mem.copy(u16, out_buffer[0..], drive_letter); |
| | 1016 | std.mem.copy(u16, out_buffer[drive_letter.len..], file_name_u16); |
| | 1017 | const total_len = drive_letter.len + file_name_u16.len; |
| | 1018 | |
| | 1019 | // Validate that DOS does not contain any spurious nul bytes. |
| | 1020 | if (std.mem.indexOfScalar(u16, out_buffer[0..total_len], 0)) |_| { |
| | 1021 | return error.BadPathName; |
| | 1022 | } |
| | 1023 | |
| | 1024 | return out_buffer[0..total_len]; |
| | 1025 | } |
| | 1026 | } |
| | 1027 | |
| | 1028 | // If we've ended up here, then something went wrong/is corrupted in the OS, |
| | 1029 | // so error out! |
| | 1030 | return error.FileNotFound; |
| | 1031 | }, |
| | 1032 | } |
| | 1033 | } |
| | 1034 | |
| | 1035 | pub const QueryInformationFileError = error{Unexpected}; |
| | 1036 | |
| | 1037 | pub fn QueryInformationFile( |
| | 1038 | handle: HANDLE, |
| | 1039 | info_class: FILE_INFORMATION_CLASS, |
| | 1040 | out_buffer: []u8, |
| | 1041 | ) QueryInformationFileError!void { |
| | 1042 | var io: IO_STATUS_BLOCK = undefined; |
| | 1043 | const len_bytes = std.math.cast(u32, out_buffer.len) catch unreachable; |
| | 1044 | const rc = ntdll.NtQueryInformationFile(handle, &io, out_buffer.ptr, len_bytes, info_class); |
| | 1045 | switch (rc) { |
| | 1046 | .SUCCESS => {}, |
| | 1047 | .INVALID_PARAMETER => unreachable, |
| | 1048 | else => return unexpectedStatus(rc), |
| 922 | } | 1049 | } |
| 923 | return buf_ptr[0..rc :0]; | | |
| 924 | } | 1050 | } |
| 925 | | 1051 | |
| 926 | pub const GetFileSizeError = error{Unexpected}; | 1052 | pub const GetFileSizeError = error{Unexpected}; |
Andrew Kelley <andrew@ziglang.org> 2020-08-10 20:09:45-04:00
GitHub <noreply@github.com> 2020-08-10 20:09:45-04:00
Signed by PGP key 4AEE18F83AFDEB23
lib