mirror of
https://github.com/ziglang/zig.git
synced 2024-11-15 08:33:06 +00:00
bc797a97b1
The old `CallingConvention` type is replaced with the new `NewCallingConvention`. References to `NewCallingConvention` in the compiler are updated accordingly. In addition, a few parts of the standard library are updated to use the new type correctly.
5659 lines
199 KiB
Zig
5659 lines
199 KiB
Zig
//! This file contains thin wrappers around Windows-specific APIs, with these
|
||
//! specific goals in mind:
|
||
//! * Convert "errno"-style error codes into Zig errors.
|
||
//! * When null-terminated or WTF16LE byte buffers are required, provide APIs which accept
|
||
//! slices as well as APIs which accept null-terminated WTF16LE byte buffers.
|
||
|
||
const builtin = @import("builtin");
|
||
const std = @import("../std.zig");
|
||
const mem = std.mem;
|
||
const assert = std.debug.assert;
|
||
const math = std.math;
|
||
const maxInt = std.math.maxInt;
|
||
const native_arch = builtin.cpu.arch;
|
||
const UnexpectedError = std.posix.UnexpectedError;
|
||
|
||
test {
|
||
if (builtin.os.tag == .windows) {
|
||
_ = @import("windows/test.zig");
|
||
}
|
||
}
|
||
|
||
pub const advapi32 = @import("windows/advapi32.zig");
|
||
pub const kernel32 = @import("windows/kernel32.zig");
|
||
pub const ntdll = @import("windows/ntdll.zig");
|
||
pub const ws2_32 = @import("windows/ws2_32.zig");
|
||
pub const crypt32 = @import("windows/crypt32.zig");
|
||
pub const nls = @import("windows/nls.zig");
|
||
|
||
pub const self_process_handle = @as(HANDLE, @ptrFromInt(maxInt(usize)));
|
||
|
||
const Self = @This();
|
||
|
||
pub const OpenError = error{
|
||
IsDir,
|
||
NotDir,
|
||
FileNotFound,
|
||
NoDevice,
|
||
AccessDenied,
|
||
PipeBusy,
|
||
PathAlreadyExists,
|
||
Unexpected,
|
||
NameTooLong,
|
||
WouldBlock,
|
||
NetworkNotFound,
|
||
AntivirusInterference,
|
||
BadPathName,
|
||
};
|
||
|
||
pub const OpenFileOptions = struct {
|
||
access_mask: ACCESS_MASK,
|
||
dir: ?HANDLE = null,
|
||
sa: ?*SECURITY_ATTRIBUTES = null,
|
||
share_access: ULONG = FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE,
|
||
creation: ULONG,
|
||
/// If true, tries to open path as a directory.
|
||
/// Defaults to false.
|
||
filter: Filter = .file_only,
|
||
/// If false, tries to open path as a reparse point without dereferencing it.
|
||
/// Defaults to true.
|
||
follow_symlinks: bool = true,
|
||
|
||
pub const Filter = enum {
|
||
/// Causes `OpenFile` to return `error.IsDir` if the opened handle would be a directory.
|
||
file_only,
|
||
/// Causes `OpenFile` to return `error.NotDir` if the opened handle would be a file.
|
||
dir_only,
|
||
/// `OpenFile` does not discriminate between opening files and directories.
|
||
any,
|
||
};
|
||
};
|
||
|
||
pub fn OpenFile(sub_path_w: []const u16, options: OpenFileOptions) OpenError!HANDLE {
|
||
if (mem.eql(u16, sub_path_w, &[_]u16{'.'}) and options.filter == .file_only) {
|
||
return error.IsDir;
|
||
}
|
||
if (mem.eql(u16, sub_path_w, &[_]u16{ '.', '.' }) and options.filter == .file_only) {
|
||
return error.IsDir;
|
||
}
|
||
|
||
var result: HANDLE = undefined;
|
||
|
||
const path_len_bytes = math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
|
||
var nt_name = UNICODE_STRING{
|
||
.Length = path_len_bytes,
|
||
.MaximumLength = path_len_bytes,
|
||
.Buffer = @constCast(sub_path_w.ptr),
|
||
};
|
||
var attr = OBJECT_ATTRIBUTES{
|
||
.Length = @sizeOf(OBJECT_ATTRIBUTES),
|
||
.RootDirectory = if (std.fs.path.isAbsoluteWindowsWTF16(sub_path_w)) null else options.dir,
|
||
.Attributes = if (options.sa) |ptr| blk: { // Note we do not use OBJ_CASE_INSENSITIVE here.
|
||
const inherit: ULONG = if (ptr.bInheritHandle == TRUE) OBJ_INHERIT else 0;
|
||
break :blk inherit;
|
||
} else 0,
|
||
.ObjectName = &nt_name,
|
||
.SecurityDescriptor = if (options.sa) |ptr| ptr.lpSecurityDescriptor else null,
|
||
.SecurityQualityOfService = null,
|
||
};
|
||
var io: IO_STATUS_BLOCK = undefined;
|
||
const blocking_flag: ULONG = FILE_SYNCHRONOUS_IO_NONALERT;
|
||
const file_or_dir_flag: ULONG = switch (options.filter) {
|
||
.file_only => FILE_NON_DIRECTORY_FILE,
|
||
.dir_only => FILE_DIRECTORY_FILE,
|
||
.any => 0,
|
||
};
|
||
// If we're not following symlinks, we need to ensure we don't pass in any synchronization flags such as FILE_SYNCHRONOUS_IO_NONALERT.
|
||
const flags: ULONG = if (options.follow_symlinks) file_or_dir_flag | blocking_flag else file_or_dir_flag | FILE_OPEN_REPARSE_POINT;
|
||
|
||
while (true) {
|
||
const rc = ntdll.NtCreateFile(
|
||
&result,
|
||
options.access_mask,
|
||
&attr,
|
||
&io,
|
||
null,
|
||
FILE_ATTRIBUTE_NORMAL,
|
||
options.share_access,
|
||
options.creation,
|
||
flags,
|
||
null,
|
||
0,
|
||
);
|
||
switch (rc) {
|
||
.SUCCESS => return result,
|
||
.OBJECT_NAME_INVALID => return error.BadPathName,
|
||
.OBJECT_NAME_NOT_FOUND => return error.FileNotFound,
|
||
.OBJECT_PATH_NOT_FOUND => return error.FileNotFound,
|
||
.BAD_NETWORK_PATH => return error.NetworkNotFound, // \\server was not found
|
||
.BAD_NETWORK_NAME => return error.NetworkNotFound, // \\server was found but \\server\share wasn't
|
||
.NO_MEDIA_IN_DEVICE => return error.NoDevice,
|
||
.INVALID_PARAMETER => unreachable,
|
||
.SHARING_VIOLATION => return error.AccessDenied,
|
||
.ACCESS_DENIED => return error.AccessDenied,
|
||
.PIPE_BUSY => return error.PipeBusy,
|
||
.OBJECT_PATH_SYNTAX_BAD => unreachable,
|
||
.OBJECT_NAME_COLLISION => return error.PathAlreadyExists,
|
||
.FILE_IS_A_DIRECTORY => return error.IsDir,
|
||
.NOT_A_DIRECTORY => return error.NotDir,
|
||
.USER_MAPPED_FILE => return error.AccessDenied,
|
||
.INVALID_HANDLE => unreachable,
|
||
.DELETE_PENDING => {
|
||
// This error means that there *was* a file in this location on
|
||
// the file system, but it was deleted. However, the OS is not
|
||
// finished with the deletion operation, and so this CreateFile
|
||
// call has failed. There is not really a sane way to handle
|
||
// this other than retrying the creation after the OS finishes
|
||
// the deletion.
|
||
std.time.sleep(std.time.ns_per_ms);
|
||
continue;
|
||
},
|
||
.VIRUS_INFECTED, .VIRUS_DELETED => return error.AntivirusInterference,
|
||
else => return unexpectedStatus(rc),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub fn GetCurrentProcess() HANDLE {
|
||
const process_pseudo_handle: usize = @bitCast(@as(isize, -1));
|
||
return @ptrFromInt(process_pseudo_handle);
|
||
}
|
||
|
||
pub fn GetCurrentProcessId() DWORD {
|
||
return @truncate(@intFromPtr(teb().ClientId.UniqueProcess));
|
||
}
|
||
|
||
pub fn GetCurrentThread() HANDLE {
|
||
const thread_pseudo_handle: usize = @bitCast(@as(isize, -2));
|
||
return @ptrFromInt(thread_pseudo_handle);
|
||
}
|
||
|
||
pub fn GetCurrentThreadId() DWORD {
|
||
return @truncate(@intFromPtr(teb().ClientId.UniqueThread));
|
||
}
|
||
|
||
pub fn GetLastError() Win32Error {
|
||
return @enumFromInt(teb().LastErrorValue);
|
||
}
|
||
|
||
pub const CreatePipeError = error{ Unexpected, SystemResources };
|
||
|
||
var npfs: ?HANDLE = null;
|
||
|
||
/// A Zig wrapper around `NtCreateNamedPipeFile` and `NtCreateFile` syscalls.
|
||
/// It implements similar behavior to `CreatePipe` and is meant to serve
|
||
/// as a direct substitute for that call.
|
||
pub fn CreatePipe(rd: *HANDLE, wr: *HANDLE, sattr: *const SECURITY_ATTRIBUTES) CreatePipeError!void {
|
||
// Up to NT 5.2 (Windows XP/Server 2003), `CreatePipe` would generate a pipe similar to:
|
||
//
|
||
// \??\pipe\Win32Pipes.{pid}.{count}
|
||
//
|
||
// where `pid` is the process id and count is a incrementing counter.
|
||
// The implementation was changed after NT 6.0 (Vista) to open a handle to the Named Pipe File System
|
||
// and use that as the root directory for `NtCreateNamedPipeFile`.
|
||
// This object is visible under the NPFS but has no filename attached to it.
|
||
//
|
||
// This implementation replicates how `CreatePipe` works in modern Windows versions.
|
||
const opt_dev_handle = @atomicLoad(?HANDLE, &npfs, .seq_cst);
|
||
const dev_handle = opt_dev_handle orelse blk: {
|
||
const str = std.unicode.utf8ToUtf16LeStringLiteral("\\Device\\NamedPipe\\");
|
||
const len: u16 = @truncate(str.len * @sizeOf(u16));
|
||
const name = UNICODE_STRING{
|
||
.Length = len,
|
||
.MaximumLength = len,
|
||
.Buffer = @constCast(@ptrCast(str)),
|
||
};
|
||
const attrs = OBJECT_ATTRIBUTES{
|
||
.ObjectName = @constCast(&name),
|
||
.Length = @sizeOf(OBJECT_ATTRIBUTES),
|
||
.RootDirectory = null,
|
||
.Attributes = 0,
|
||
.SecurityDescriptor = null,
|
||
.SecurityQualityOfService = null,
|
||
};
|
||
|
||
var iosb: IO_STATUS_BLOCK = undefined;
|
||
var handle: HANDLE = undefined;
|
||
switch (ntdll.NtCreateFile(
|
||
&handle,
|
||
GENERIC_READ | SYNCHRONIZE,
|
||
@constCast(&attrs),
|
||
&iosb,
|
||
null,
|
||
0,
|
||
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
||
FILE_OPEN,
|
||
FILE_SYNCHRONOUS_IO_NONALERT,
|
||
null,
|
||
0,
|
||
)) {
|
||
.SUCCESS => {},
|
||
// Judging from the ReactOS sources this is technically possible.
|
||
.INSUFFICIENT_RESOURCES => return error.SystemResources,
|
||
.INVALID_PARAMETER => unreachable,
|
||
else => |e| return unexpectedStatus(e),
|
||
}
|
||
if (@cmpxchgStrong(?HANDLE, &npfs, null, handle, .seq_cst, .seq_cst)) |xchg| {
|
||
CloseHandle(handle);
|
||
break :blk xchg.?;
|
||
} else break :blk handle;
|
||
};
|
||
|
||
const name = UNICODE_STRING{ .Buffer = null, .Length = 0, .MaximumLength = 0 };
|
||
var attrs = OBJECT_ATTRIBUTES{
|
||
.ObjectName = @constCast(&name),
|
||
.Length = @sizeOf(OBJECT_ATTRIBUTES),
|
||
.RootDirectory = dev_handle,
|
||
.Attributes = OBJ_CASE_INSENSITIVE,
|
||
.SecurityDescriptor = sattr.lpSecurityDescriptor,
|
||
.SecurityQualityOfService = null,
|
||
};
|
||
if (sattr.bInheritHandle != 0) attrs.Attributes |= OBJ_INHERIT;
|
||
|
||
// 120 second relative timeout in 100ns units.
|
||
const default_timeout: LARGE_INTEGER = (-120 * std.time.ns_per_s) / 100;
|
||
var iosb: IO_STATUS_BLOCK = undefined;
|
||
var read: HANDLE = undefined;
|
||
switch (ntdll.NtCreateNamedPipeFile(
|
||
&read,
|
||
GENERIC_READ | FILE_WRITE_ATTRIBUTES | SYNCHRONIZE,
|
||
&attrs,
|
||
&iosb,
|
||
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
||
FILE_CREATE,
|
||
FILE_SYNCHRONOUS_IO_NONALERT,
|
||
FILE_PIPE_BYTE_STREAM_TYPE,
|
||
FILE_PIPE_BYTE_STREAM_MODE,
|
||
FILE_PIPE_QUEUE_OPERATION,
|
||
1,
|
||
4096,
|
||
4096,
|
||
@constCast(&default_timeout),
|
||
)) {
|
||
.SUCCESS => {},
|
||
.INVALID_PARAMETER => unreachable,
|
||
.INSUFFICIENT_RESOURCES => return error.SystemResources,
|
||
else => |e| return unexpectedStatus(e),
|
||
}
|
||
errdefer CloseHandle(read);
|
||
|
||
attrs.RootDirectory = read;
|
||
|
||
var write: HANDLE = undefined;
|
||
switch (ntdll.NtCreateFile(
|
||
&write,
|
||
GENERIC_WRITE | SYNCHRONIZE | FILE_READ_ATTRIBUTES,
|
||
&attrs,
|
||
&iosb,
|
||
null,
|
||
0,
|
||
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
||
FILE_OPEN,
|
||
FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE,
|
||
null,
|
||
0,
|
||
)) {
|
||
.SUCCESS => {},
|
||
.INVALID_PARAMETER => unreachable,
|
||
.INSUFFICIENT_RESOURCES => return error.SystemResources,
|
||
else => |e| return unexpectedStatus(e),
|
||
}
|
||
|
||
rd.* = read;
|
||
wr.* = write;
|
||
}
|
||
|
||
pub fn CreateEventEx(attributes: ?*SECURITY_ATTRIBUTES, name: []const u8, flags: DWORD, desired_access: DWORD) !HANDLE {
|
||
const nameW = try sliceToPrefixedFileW(null, name);
|
||
return CreateEventExW(attributes, nameW.span().ptr, flags, desired_access);
|
||
}
|
||
|
||
pub fn CreateEventExW(attributes: ?*SECURITY_ATTRIBUTES, nameW: ?LPCWSTR, flags: DWORD, desired_access: DWORD) !HANDLE {
|
||
const handle = kernel32.CreateEventExW(attributes, nameW, flags, desired_access);
|
||
if (handle) |h| {
|
||
return h;
|
||
} else {
|
||
switch (GetLastError()) {
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub const DeviceIoControlError = error{
|
||
AccessDenied,
|
||
/// The volume does not contain a recognized file system. File system
|
||
/// drivers might not be loaded, or the volume may be corrupt.
|
||
UnrecognizedVolume,
|
||
Unexpected,
|
||
};
|
||
|
||
/// A Zig wrapper around `NtDeviceIoControlFile` and `NtFsControlFile` syscalls.
|
||
/// It implements similar behavior to `DeviceIoControl` and is meant to serve
|
||
/// as a direct substitute for that call.
|
||
/// TODO work out if we need to expose other arguments to the underlying syscalls.
|
||
pub fn DeviceIoControl(
|
||
h: HANDLE,
|
||
ioControlCode: ULONG,
|
||
in: ?[]const u8,
|
||
out: ?[]u8,
|
||
) DeviceIoControlError!void {
|
||
// Logic from: https://doxygen.reactos.org/d3/d74/deviceio_8c.html
|
||
const is_fsctl = (ioControlCode >> 16) == FILE_DEVICE_FILE_SYSTEM;
|
||
|
||
var io: IO_STATUS_BLOCK = undefined;
|
||
const in_ptr = if (in) |i| i.ptr else null;
|
||
const in_len = if (in) |i| @as(ULONG, @intCast(i.len)) else 0;
|
||
const out_ptr = if (out) |o| o.ptr else null;
|
||
const out_len = if (out) |o| @as(ULONG, @intCast(o.len)) else 0;
|
||
|
||
const rc = blk: {
|
||
if (is_fsctl) {
|
||
break :blk ntdll.NtFsControlFile(
|
||
h,
|
||
null,
|
||
null,
|
||
null,
|
||
&io,
|
||
ioControlCode,
|
||
in_ptr,
|
||
in_len,
|
||
out_ptr,
|
||
out_len,
|
||
);
|
||
} else {
|
||
break :blk ntdll.NtDeviceIoControlFile(
|
||
h,
|
||
null,
|
||
null,
|
||
null,
|
||
&io,
|
||
ioControlCode,
|
||
in_ptr,
|
||
in_len,
|
||
out_ptr,
|
||
out_len,
|
||
);
|
||
}
|
||
};
|
||
switch (rc) {
|
||
.SUCCESS => {},
|
||
.PRIVILEGE_NOT_HELD => return error.AccessDenied,
|
||
.ACCESS_DENIED => return error.AccessDenied,
|
||
.INVALID_DEVICE_REQUEST => return error.AccessDenied, // Not supported by the underlying filesystem
|
||
.INVALID_PARAMETER => unreachable,
|
||
.UNRECOGNIZED_VOLUME => return error.UnrecognizedVolume,
|
||
else => return unexpectedStatus(rc),
|
||
}
|
||
}
|
||
|
||
pub fn GetOverlappedResult(h: HANDLE, overlapped: *OVERLAPPED, wait: bool) !DWORD {
|
||
var bytes: DWORD = undefined;
|
||
if (kernel32.GetOverlappedResult(h, overlapped, &bytes, @intFromBool(wait)) == 0) {
|
||
switch (GetLastError()) {
|
||
.IO_INCOMPLETE => if (!wait) return error.WouldBlock else unreachable,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
return bytes;
|
||
}
|
||
|
||
pub const SetHandleInformationError = error{Unexpected};
|
||
|
||
pub fn SetHandleInformation(h: HANDLE, mask: DWORD, flags: DWORD) SetHandleInformationError!void {
|
||
if (kernel32.SetHandleInformation(h, mask, flags) == 0) {
|
||
switch (GetLastError()) {
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub const RtlGenRandomError = error{Unexpected};
|
||
|
||
/// Call RtlGenRandom() instead of CryptGetRandom() on Windows
|
||
/// https://github.com/rust-lang-nursery/rand/issues/111
|
||
/// https://bugzilla.mozilla.org/show_bug.cgi?id=504270
|
||
pub fn RtlGenRandom(output: []u8) RtlGenRandomError!void {
|
||
var total_read: usize = 0;
|
||
var buff: []u8 = output[0..];
|
||
const max_read_size: ULONG = maxInt(ULONG);
|
||
|
||
while (total_read < output.len) {
|
||
const to_read: ULONG = @min(buff.len, max_read_size);
|
||
|
||
if (advapi32.RtlGenRandom(buff.ptr, to_read) == 0) {
|
||
return unexpectedError(GetLastError());
|
||
}
|
||
|
||
total_read += to_read;
|
||
buff = buff[to_read..];
|
||
}
|
||
}
|
||
|
||
pub const WaitForSingleObjectError = error{
|
||
WaitAbandoned,
|
||
WaitTimeOut,
|
||
Unexpected,
|
||
};
|
||
|
||
pub fn WaitForSingleObject(handle: HANDLE, milliseconds: DWORD) WaitForSingleObjectError!void {
|
||
return WaitForSingleObjectEx(handle, milliseconds, false);
|
||
}
|
||
|
||
pub fn WaitForSingleObjectEx(handle: HANDLE, milliseconds: DWORD, alertable: bool) WaitForSingleObjectError!void {
|
||
switch (kernel32.WaitForSingleObjectEx(handle, milliseconds, @intFromBool(alertable))) {
|
||
WAIT_ABANDONED => return error.WaitAbandoned,
|
||
WAIT_OBJECT_0 => return,
|
||
WAIT_TIMEOUT => return error.WaitTimeOut,
|
||
WAIT_FAILED => switch (GetLastError()) {
|
||
else => |err| return unexpectedError(err),
|
||
},
|
||
else => return error.Unexpected,
|
||
}
|
||
}
|
||
|
||
pub fn WaitForMultipleObjectsEx(handles: []const HANDLE, waitAll: bool, milliseconds: DWORD, alertable: bool) !u32 {
|
||
assert(handles.len > 0 and handles.len <= MAXIMUM_WAIT_OBJECTS);
|
||
const nCount: DWORD = @as(DWORD, @intCast(handles.len));
|
||
switch (kernel32.WaitForMultipleObjectsEx(
|
||
nCount,
|
||
handles.ptr,
|
||
@intFromBool(waitAll),
|
||
milliseconds,
|
||
@intFromBool(alertable),
|
||
)) {
|
||
WAIT_OBJECT_0...WAIT_OBJECT_0 + MAXIMUM_WAIT_OBJECTS => |n| {
|
||
const handle_index = n - WAIT_OBJECT_0;
|
||
assert(handle_index < nCount);
|
||
return handle_index;
|
||
},
|
||
WAIT_ABANDONED_0...WAIT_ABANDONED_0 + MAXIMUM_WAIT_OBJECTS => |n| {
|
||
const handle_index = n - WAIT_ABANDONED_0;
|
||
assert(handle_index < nCount);
|
||
return error.WaitAbandoned;
|
||
},
|
||
WAIT_TIMEOUT => return error.WaitTimeOut,
|
||
WAIT_FAILED => switch (GetLastError()) {
|
||
else => |err| return unexpectedError(err),
|
||
},
|
||
else => return error.Unexpected,
|
||
}
|
||
}
|
||
|
||
pub const CreateIoCompletionPortError = error{Unexpected};
|
||
|
||
pub fn CreateIoCompletionPort(
|
||
file_handle: HANDLE,
|
||
existing_completion_port: ?HANDLE,
|
||
completion_key: usize,
|
||
concurrent_thread_count: DWORD,
|
||
) CreateIoCompletionPortError!HANDLE {
|
||
const handle = kernel32.CreateIoCompletionPort(file_handle, existing_completion_port, completion_key, concurrent_thread_count) orelse {
|
||
switch (GetLastError()) {
|
||
.INVALID_PARAMETER => unreachable,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
};
|
||
return handle;
|
||
}
|
||
|
||
pub const PostQueuedCompletionStatusError = error{Unexpected};
|
||
|
||
pub fn PostQueuedCompletionStatus(
|
||
completion_port: HANDLE,
|
||
bytes_transferred_count: DWORD,
|
||
completion_key: usize,
|
||
lpOverlapped: ?*OVERLAPPED,
|
||
) PostQueuedCompletionStatusError!void {
|
||
if (kernel32.PostQueuedCompletionStatus(completion_port, bytes_transferred_count, completion_key, lpOverlapped) == 0) {
|
||
switch (GetLastError()) {
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub const GetQueuedCompletionStatusResult = enum {
|
||
Normal,
|
||
Aborted,
|
||
Cancelled,
|
||
EOF,
|
||
Timeout,
|
||
};
|
||
|
||
pub fn GetQueuedCompletionStatus(
|
||
completion_port: HANDLE,
|
||
bytes_transferred_count: *DWORD,
|
||
lpCompletionKey: *usize,
|
||
lpOverlapped: *?*OVERLAPPED,
|
||
dwMilliseconds: DWORD,
|
||
) GetQueuedCompletionStatusResult {
|
||
if (kernel32.GetQueuedCompletionStatus(
|
||
completion_port,
|
||
bytes_transferred_count,
|
||
lpCompletionKey,
|
||
lpOverlapped,
|
||
dwMilliseconds,
|
||
) == FALSE) {
|
||
switch (GetLastError()) {
|
||
.ABANDONED_WAIT_0 => return GetQueuedCompletionStatusResult.Aborted,
|
||
.OPERATION_ABORTED => return GetQueuedCompletionStatusResult.Cancelled,
|
||
.HANDLE_EOF => return GetQueuedCompletionStatusResult.EOF,
|
||
.WAIT_TIMEOUT => return GetQueuedCompletionStatusResult.Timeout,
|
||
else => |err| {
|
||
if (std.debug.runtime_safety) {
|
||
@setEvalBranchQuota(2500);
|
||
std.debug.panic("unexpected error: {}\n", .{err});
|
||
}
|
||
},
|
||
}
|
||
}
|
||
return GetQueuedCompletionStatusResult.Normal;
|
||
}
|
||
|
||
pub const GetQueuedCompletionStatusError = error{
|
||
Aborted,
|
||
Cancelled,
|
||
EOF,
|
||
Timeout,
|
||
} || UnexpectedError;
|
||
|
||
pub fn GetQueuedCompletionStatusEx(
|
||
completion_port: HANDLE,
|
||
completion_port_entries: []OVERLAPPED_ENTRY,
|
||
timeout_ms: ?DWORD,
|
||
alertable: bool,
|
||
) GetQueuedCompletionStatusError!u32 {
|
||
var num_entries_removed: u32 = 0;
|
||
|
||
const success = kernel32.GetQueuedCompletionStatusEx(
|
||
completion_port,
|
||
completion_port_entries.ptr,
|
||
@as(ULONG, @intCast(completion_port_entries.len)),
|
||
&num_entries_removed,
|
||
timeout_ms orelse INFINITE,
|
||
@intFromBool(alertable),
|
||
);
|
||
|
||
if (success == FALSE) {
|
||
return switch (GetLastError()) {
|
||
.ABANDONED_WAIT_0 => error.Aborted,
|
||
.OPERATION_ABORTED => error.Cancelled,
|
||
.HANDLE_EOF => error.EOF,
|
||
.WAIT_TIMEOUT => error.Timeout,
|
||
else => |err| unexpectedError(err),
|
||
};
|
||
}
|
||
|
||
return num_entries_removed;
|
||
}
|
||
|
||
pub fn CloseHandle(hObject: HANDLE) void {
|
||
assert(ntdll.NtClose(hObject) == .SUCCESS);
|
||
}
|
||
|
||
pub fn FindClose(hFindFile: HANDLE) void {
|
||
assert(kernel32.FindClose(hFindFile) != 0);
|
||
}
|
||
|
||
pub const ReadFileError = error{
|
||
BrokenPipe,
|
||
/// The specified network name is no longer available.
|
||
ConnectionResetByPeer,
|
||
OperationAborted,
|
||
/// Unable to read file due to lock.
|
||
LockViolation,
|
||
Unexpected,
|
||
};
|
||
|
||
/// If buffer's length exceeds what a Windows DWORD integer can hold, it will be broken into
|
||
/// multiple non-atomic reads.
|
||
pub fn ReadFile(in_hFile: HANDLE, buffer: []u8, offset: ?u64) ReadFileError!usize {
|
||
while (true) {
|
||
const want_read_count: DWORD = @min(@as(DWORD, maxInt(DWORD)), buffer.len);
|
||
var amt_read: DWORD = undefined;
|
||
var overlapped_data: OVERLAPPED = undefined;
|
||
const overlapped: ?*OVERLAPPED = if (offset) |off| blk: {
|
||
overlapped_data = .{
|
||
.Internal = 0,
|
||
.InternalHigh = 0,
|
||
.DUMMYUNIONNAME = .{
|
||
.DUMMYSTRUCTNAME = .{
|
||
.Offset = @as(u32, @truncate(off)),
|
||
.OffsetHigh = @as(u32, @truncate(off >> 32)),
|
||
},
|
||
},
|
||
.hEvent = null,
|
||
};
|
||
break :blk &overlapped_data;
|
||
} else null;
|
||
if (kernel32.ReadFile(in_hFile, buffer.ptr, want_read_count, &amt_read, overlapped) == 0) {
|
||
switch (GetLastError()) {
|
||
.IO_PENDING => unreachable,
|
||
.OPERATION_ABORTED => continue,
|
||
.BROKEN_PIPE => return 0,
|
||
.HANDLE_EOF => return 0,
|
||
.NETNAME_DELETED => return error.ConnectionResetByPeer,
|
||
.LOCK_VIOLATION => return error.LockViolation,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
return amt_read;
|
||
}
|
||
}
|
||
|
||
pub const WriteFileError = error{
|
||
SystemResources,
|
||
OperationAborted,
|
||
BrokenPipe,
|
||
NotOpenForWriting,
|
||
/// The process cannot access the file because another process has locked
|
||
/// a portion of the file.
|
||
LockViolation,
|
||
/// The specified network name is no longer available.
|
||
ConnectionResetByPeer,
|
||
Unexpected,
|
||
};
|
||
|
||
pub fn WriteFile(
|
||
handle: HANDLE,
|
||
bytes: []const u8,
|
||
offset: ?u64,
|
||
) WriteFileError!usize {
|
||
var bytes_written: DWORD = undefined;
|
||
var overlapped_data: OVERLAPPED = undefined;
|
||
const overlapped: ?*OVERLAPPED = if (offset) |off| blk: {
|
||
overlapped_data = .{
|
||
.Internal = 0,
|
||
.InternalHigh = 0,
|
||
.DUMMYUNIONNAME = .{
|
||
.DUMMYSTRUCTNAME = .{
|
||
.Offset = @truncate(off),
|
||
.OffsetHigh = @truncate(off >> 32),
|
||
},
|
||
},
|
||
.hEvent = null,
|
||
};
|
||
break :blk &overlapped_data;
|
||
} else null;
|
||
const adjusted_len = math.cast(u32, bytes.len) orelse maxInt(u32);
|
||
if (kernel32.WriteFile(handle, bytes.ptr, adjusted_len, &bytes_written, overlapped) == 0) {
|
||
switch (GetLastError()) {
|
||
.INVALID_USER_BUFFER => return error.SystemResources,
|
||
.NOT_ENOUGH_MEMORY => return error.SystemResources,
|
||
.OPERATION_ABORTED => return error.OperationAborted,
|
||
.NOT_ENOUGH_QUOTA => return error.SystemResources,
|
||
.IO_PENDING => unreachable,
|
||
.BROKEN_PIPE => return error.BrokenPipe,
|
||
.INVALID_HANDLE => return error.NotOpenForWriting,
|
||
.LOCK_VIOLATION => return error.LockViolation,
|
||
.NETNAME_DELETED => return error.ConnectionResetByPeer,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
return bytes_written;
|
||
}
|
||
|
||
pub const SetCurrentDirectoryError = error{
|
||
NameTooLong,
|
||
FileNotFound,
|
||
NotDir,
|
||
AccessDenied,
|
||
NoDevice,
|
||
BadPathName,
|
||
Unexpected,
|
||
};
|
||
|
||
pub fn SetCurrentDirectory(path_name: []const u16) SetCurrentDirectoryError!void {
|
||
const path_len_bytes = math.cast(u16, path_name.len * 2) orelse return error.NameTooLong;
|
||
|
||
var nt_name = UNICODE_STRING{
|
||
.Length = path_len_bytes,
|
||
.MaximumLength = path_len_bytes,
|
||
.Buffer = @constCast(path_name.ptr),
|
||
};
|
||
|
||
const rc = ntdll.RtlSetCurrentDirectory_U(&nt_name);
|
||
switch (rc) {
|
||
.SUCCESS => {},
|
||
.OBJECT_NAME_INVALID => return error.BadPathName,
|
||
.OBJECT_NAME_NOT_FOUND => return error.FileNotFound,
|
||
.OBJECT_PATH_NOT_FOUND => return error.FileNotFound,
|
||
.NO_MEDIA_IN_DEVICE => return error.NoDevice,
|
||
.INVALID_PARAMETER => unreachable,
|
||
.ACCESS_DENIED => return error.AccessDenied,
|
||
.OBJECT_PATH_SYNTAX_BAD => unreachable,
|
||
.NOT_A_DIRECTORY => return error.NotDir,
|
||
else => return unexpectedStatus(rc),
|
||
}
|
||
}
|
||
|
||
pub const GetCurrentDirectoryError = error{
|
||
NameTooLong,
|
||
Unexpected,
|
||
};
|
||
|
||
/// The result is a slice of `buffer`, indexed from 0.
|
||
/// The result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
|
||
pub fn GetCurrentDirectory(buffer: []u8) GetCurrentDirectoryError![]u8 {
|
||
var wtf16le_buf: [PATH_MAX_WIDE:0]u16 = undefined;
|
||
const result = kernel32.GetCurrentDirectoryW(wtf16le_buf.len + 1, &wtf16le_buf);
|
||
if (result == 0) {
|
||
switch (GetLastError()) {
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
assert(result <= wtf16le_buf.len);
|
||
const wtf16le_slice = wtf16le_buf[0..result];
|
||
var end_index: usize = 0;
|
||
var it = std.unicode.Wtf16LeIterator.init(wtf16le_slice);
|
||
while (it.nextCodepoint()) |codepoint| {
|
||
const seq_len = std.unicode.utf8CodepointSequenceLength(codepoint) catch unreachable;
|
||
if (end_index + seq_len >= buffer.len)
|
||
return error.NameTooLong;
|
||
end_index += std.unicode.wtf8Encode(codepoint, buffer[end_index..]) catch unreachable;
|
||
}
|
||
return buffer[0..end_index];
|
||
}
|
||
|
||
pub const CreateSymbolicLinkError = error{
|
||
AccessDenied,
|
||
PathAlreadyExists,
|
||
FileNotFound,
|
||
NameTooLong,
|
||
NoDevice,
|
||
NetworkNotFound,
|
||
BadPathName,
|
||
/// The volume does not contain a recognized file system. File system
|
||
/// drivers might not be loaded, or the volume may be corrupt.
|
||
UnrecognizedVolume,
|
||
Unexpected,
|
||
};
|
||
|
||
/// Needs either:
|
||
/// - `SeCreateSymbolicLinkPrivilege` privilege
|
||
/// or
|
||
/// - Developer mode on Windows 10
|
||
/// otherwise fails with `error.AccessDenied`. In which case `sym_link_path` may still
|
||
/// be created on the file system but will lack reparse processing data applied to it.
|
||
pub fn CreateSymbolicLink(
|
||
dir: ?HANDLE,
|
||
sym_link_path: []const u16,
|
||
target_path: [:0]const u16,
|
||
is_directory: bool,
|
||
) CreateSymbolicLinkError!void {
|
||
const SYMLINK_DATA = extern struct {
|
||
ReparseTag: ULONG,
|
||
ReparseDataLength: USHORT,
|
||
Reserved: USHORT,
|
||
SubstituteNameOffset: USHORT,
|
||
SubstituteNameLength: USHORT,
|
||
PrintNameOffset: USHORT,
|
||
PrintNameLength: USHORT,
|
||
Flags: ULONG,
|
||
};
|
||
|
||
const symlink_handle = OpenFile(sym_link_path, .{
|
||
.access_mask = SYNCHRONIZE | GENERIC_READ | GENERIC_WRITE,
|
||
.dir = dir,
|
||
.creation = FILE_CREATE,
|
||
.filter = if (is_directory) .dir_only else .file_only,
|
||
}) catch |err| switch (err) {
|
||
error.IsDir => return error.PathAlreadyExists,
|
||
error.NotDir => return error.Unexpected,
|
||
error.WouldBlock => return error.Unexpected,
|
||
error.PipeBusy => return error.Unexpected,
|
||
error.AntivirusInterference => return error.Unexpected,
|
||
else => |e| return e,
|
||
};
|
||
defer CloseHandle(symlink_handle);
|
||
|
||
// Relevant portions of the documentation:
|
||
// > Relative links are specified using the following conventions:
|
||
// > - Root relative—for example, "\Windows\System32" resolves to "current drive:\Windows\System32".
|
||
// > - Current working directory–relative—for example, if the current working directory is
|
||
// > C:\Windows\System32, "C:File.txt" resolves to "C:\Windows\System32\File.txt".
|
||
// > Note: If you specify a current working directory–relative link, it is created as an absolute
|
||
// > link, due to the way the current working directory is processed based on the user and the thread.
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createsymboliclinkw
|
||
var is_target_absolute = false;
|
||
const final_target_path = target_path: {
|
||
switch (getNamespacePrefix(u16, target_path)) {
|
||
.none => switch (getUnprefixedPathType(u16, target_path)) {
|
||
// Rooted paths need to avoid getting put through wToPrefixedFileW
|
||
// (and they are treated as relative in this context)
|
||
// Note: It seems that rooted paths in symbolic links are relative to
|
||
// the drive that the symbolic exists on, not to the CWD's drive.
|
||
// So, if the symlink is on C:\ and the CWD is on D:\,
|
||
// it will still resolve the path relative to the root of
|
||
// the C:\ drive.
|
||
.rooted => break :target_path target_path,
|
||
// Keep relative paths relative, but anything else needs to get NT-prefixed.
|
||
else => if (!std.fs.path.isAbsoluteWindowsWTF16(target_path))
|
||
break :target_path target_path,
|
||
},
|
||
// Already an NT path, no need to do anything to it
|
||
.nt => break :target_path target_path,
|
||
else => {},
|
||
}
|
||
var prefixed_target_path = try wToPrefixedFileW(dir, target_path);
|
||
// We do this after prefixing to ensure that drive-relative paths are treated as absolute
|
||
is_target_absolute = std.fs.path.isAbsoluteWindowsWTF16(prefixed_target_path.span());
|
||
break :target_path prefixed_target_path.span();
|
||
};
|
||
|
||
// prepare reparse data buffer
|
||
var buffer: [MAXIMUM_REPARSE_DATA_BUFFER_SIZE]u8 = undefined;
|
||
const buf_len = @sizeOf(SYMLINK_DATA) + final_target_path.len * 4;
|
||
const header_len = @sizeOf(ULONG) + @sizeOf(USHORT) * 2;
|
||
const target_is_absolute = std.fs.path.isAbsoluteWindowsWTF16(final_target_path);
|
||
const symlink_data = SYMLINK_DATA{
|
||
.ReparseTag = IO_REPARSE_TAG_SYMLINK,
|
||
.ReparseDataLength = @intCast(buf_len - header_len),
|
||
.Reserved = 0,
|
||
.SubstituteNameOffset = @intCast(final_target_path.len * 2),
|
||
.SubstituteNameLength = @intCast(final_target_path.len * 2),
|
||
.PrintNameOffset = 0,
|
||
.PrintNameLength = @intCast(final_target_path.len * 2),
|
||
.Flags = if (!target_is_absolute) SYMLINK_FLAG_RELATIVE else 0,
|
||
};
|
||
|
||
@memcpy(buffer[0..@sizeOf(SYMLINK_DATA)], std.mem.asBytes(&symlink_data));
|
||
@memcpy(buffer[@sizeOf(SYMLINK_DATA)..][0 .. final_target_path.len * 2], @as([*]const u8, @ptrCast(final_target_path)));
|
||
const paths_start = @sizeOf(SYMLINK_DATA) + final_target_path.len * 2;
|
||
@memcpy(buffer[paths_start..][0 .. final_target_path.len * 2], @as([*]const u8, @ptrCast(final_target_path)));
|
||
_ = try DeviceIoControl(symlink_handle, FSCTL_SET_REPARSE_POINT, buffer[0..buf_len], null);
|
||
}
|
||
|
||
pub const ReadLinkError = error{
|
||
FileNotFound,
|
||
NetworkNotFound,
|
||
AccessDenied,
|
||
Unexpected,
|
||
NameTooLong,
|
||
UnsupportedReparsePointType,
|
||
};
|
||
|
||
pub fn ReadLink(dir: ?HANDLE, sub_path_w: []const u16, out_buffer: []u8) ReadLinkError![]u8 {
|
||
// Here, we use `NtCreateFile` to shave off one syscall if we were to use `OpenFile` wrapper.
|
||
// With the latter, we'd need to call `NtCreateFile` twice, once for file symlink, and if that
|
||
// failed, again for dir symlink. Omitting any mention of file/dir flags makes it possible
|
||
// to open the symlink there and then.
|
||
const path_len_bytes = math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
|
||
var nt_name = UNICODE_STRING{
|
||
.Length = path_len_bytes,
|
||
.MaximumLength = path_len_bytes,
|
||
.Buffer = @constCast(sub_path_w.ptr),
|
||
};
|
||
var attr = OBJECT_ATTRIBUTES{
|
||
.Length = @sizeOf(OBJECT_ATTRIBUTES),
|
||
.RootDirectory = if (std.fs.path.isAbsoluteWindowsWTF16(sub_path_w)) null else dir,
|
||
.Attributes = 0, // Note we do not use OBJ_CASE_INSENSITIVE here.
|
||
.ObjectName = &nt_name,
|
||
.SecurityDescriptor = null,
|
||
.SecurityQualityOfService = null,
|
||
};
|
||
var result_handle: HANDLE = undefined;
|
||
var io: IO_STATUS_BLOCK = undefined;
|
||
|
||
const rc = ntdll.NtCreateFile(
|
||
&result_handle,
|
||
FILE_READ_ATTRIBUTES | SYNCHRONIZE,
|
||
&attr,
|
||
&io,
|
||
null,
|
||
FILE_ATTRIBUTE_NORMAL,
|
||
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
||
FILE_OPEN,
|
||
FILE_OPEN_REPARSE_POINT | FILE_SYNCHRONOUS_IO_NONALERT,
|
||
null,
|
||
0,
|
||
);
|
||
switch (rc) {
|
||
.SUCCESS => {},
|
||
.OBJECT_NAME_INVALID => unreachable,
|
||
.OBJECT_NAME_NOT_FOUND => return error.FileNotFound,
|
||
.OBJECT_PATH_NOT_FOUND => return error.FileNotFound,
|
||
.NO_MEDIA_IN_DEVICE => return error.FileNotFound,
|
||
.BAD_NETWORK_PATH => return error.NetworkNotFound, // \\server was not found
|
||
.BAD_NETWORK_NAME => return error.NetworkNotFound, // \\server was found but \\server\share wasn't
|
||
.INVALID_PARAMETER => unreachable,
|
||
.SHARING_VIOLATION => return error.AccessDenied,
|
||
.ACCESS_DENIED => return error.AccessDenied,
|
||
.PIPE_BUSY => return error.AccessDenied,
|
||
.OBJECT_PATH_SYNTAX_BAD => unreachable,
|
||
.OBJECT_NAME_COLLISION => unreachable,
|
||
.FILE_IS_A_DIRECTORY => unreachable,
|
||
else => return unexpectedStatus(rc),
|
||
}
|
||
defer CloseHandle(result_handle);
|
||
|
||
var reparse_buf: [MAXIMUM_REPARSE_DATA_BUFFER_SIZE]u8 align(@alignOf(REPARSE_DATA_BUFFER)) = undefined;
|
||
_ = DeviceIoControl(result_handle, FSCTL_GET_REPARSE_POINT, null, reparse_buf[0..]) catch |err| switch (err) {
|
||
error.AccessDenied => return error.Unexpected,
|
||
error.UnrecognizedVolume => return error.Unexpected,
|
||
else => |e| return e,
|
||
};
|
||
|
||
const reparse_struct: *const REPARSE_DATA_BUFFER = @ptrCast(@alignCast(&reparse_buf[0]));
|
||
switch (reparse_struct.ReparseTag) {
|
||
IO_REPARSE_TAG_SYMLINK => {
|
||
const buf: *const SYMBOLIC_LINK_REPARSE_BUFFER = @ptrCast(@alignCast(&reparse_struct.DataBuffer[0]));
|
||
const offset = buf.SubstituteNameOffset >> 1;
|
||
const len = buf.SubstituteNameLength >> 1;
|
||
const path_buf = @as([*]const u16, &buf.PathBuffer);
|
||
const is_relative = buf.Flags & SYMLINK_FLAG_RELATIVE != 0;
|
||
return parseReadlinkPath(path_buf[offset..][0..len], is_relative, out_buffer);
|
||
},
|
||
IO_REPARSE_TAG_MOUNT_POINT => {
|
||
const buf: *const MOUNT_POINT_REPARSE_BUFFER = @ptrCast(@alignCast(&reparse_struct.DataBuffer[0]));
|
||
const offset = buf.SubstituteNameOffset >> 1;
|
||
const len = buf.SubstituteNameLength >> 1;
|
||
const path_buf = @as([*]const u16, &buf.PathBuffer);
|
||
return parseReadlinkPath(path_buf[offset..][0..len], false, out_buffer);
|
||
},
|
||
else => |value| {
|
||
std.debug.print("unsupported symlink type: {}", .{value});
|
||
return error.UnsupportedReparsePointType;
|
||
},
|
||
}
|
||
}
|
||
|
||
/// Asserts that there is enough space is `out_buffer`.
|
||
/// The result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
|
||
fn parseReadlinkPath(path: []const u16, is_relative: bool, out_buffer: []u8) []u8 {
|
||
const win32_namespace_path = path: {
|
||
if (is_relative) break :path path;
|
||
const win32_path = ntToWin32Namespace(path) catch |err| switch (err) {
|
||
error.NameTooLong => unreachable,
|
||
error.NotNtPath => break :path path,
|
||
};
|
||
break :path win32_path.span();
|
||
};
|
||
const out_len = std.unicode.wtf16LeToWtf8(out_buffer, win32_namespace_path);
|
||
return out_buffer[0..out_len];
|
||
}
|
||
|
||
pub const DeleteFileError = error{
|
||
FileNotFound,
|
||
AccessDenied,
|
||
NameTooLong,
|
||
/// Also known as sharing violation.
|
||
FileBusy,
|
||
Unexpected,
|
||
NotDir,
|
||
IsDir,
|
||
DirNotEmpty,
|
||
NetworkNotFound,
|
||
};
|
||
|
||
pub const DeleteFileOptions = struct {
|
||
dir: ?HANDLE,
|
||
remove_dir: bool = false,
|
||
};
|
||
|
||
pub fn DeleteFile(sub_path_w: []const u16, options: DeleteFileOptions) DeleteFileError!void {
|
||
const create_options_flags: ULONG = if (options.remove_dir)
|
||
FILE_DIRECTORY_FILE | FILE_OPEN_REPARSE_POINT
|
||
else
|
||
FILE_NON_DIRECTORY_FILE | FILE_OPEN_REPARSE_POINT; // would we ever want to delete the target instead?
|
||
|
||
const path_len_bytes = @as(u16, @intCast(sub_path_w.len * 2));
|
||
var nt_name = UNICODE_STRING{
|
||
.Length = path_len_bytes,
|
||
.MaximumLength = path_len_bytes,
|
||
// The Windows API makes this mutable, but it will not mutate here.
|
||
.Buffer = @constCast(sub_path_w.ptr),
|
||
};
|
||
|
||
if (sub_path_w[0] == '.' and sub_path_w[1] == 0) {
|
||
// Windows does not recognize this, but it does work with empty string.
|
||
nt_name.Length = 0;
|
||
}
|
||
if (sub_path_w[0] == '.' and sub_path_w[1] == '.' and sub_path_w[2] == 0) {
|
||
// Can't remove the parent directory with an open handle.
|
||
return error.FileBusy;
|
||
}
|
||
|
||
var attr = OBJECT_ATTRIBUTES{
|
||
.Length = @sizeOf(OBJECT_ATTRIBUTES),
|
||
.RootDirectory = if (std.fs.path.isAbsoluteWindowsWTF16(sub_path_w)) null else options.dir,
|
||
.Attributes = 0, // Note we do not use OBJ_CASE_INSENSITIVE here.
|
||
.ObjectName = &nt_name,
|
||
.SecurityDescriptor = null,
|
||
.SecurityQualityOfService = null,
|
||
};
|
||
var io: IO_STATUS_BLOCK = undefined;
|
||
var tmp_handle: HANDLE = undefined;
|
||
var rc = ntdll.NtCreateFile(
|
||
&tmp_handle,
|
||
SYNCHRONIZE | DELETE,
|
||
&attr,
|
||
&io,
|
||
null,
|
||
0,
|
||
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
||
FILE_OPEN,
|
||
create_options_flags,
|
||
null,
|
||
0,
|
||
);
|
||
switch (rc) {
|
||
.SUCCESS => {},
|
||
.OBJECT_NAME_INVALID => unreachable,
|
||
.OBJECT_NAME_NOT_FOUND => return error.FileNotFound,
|
||
.OBJECT_PATH_NOT_FOUND => return error.FileNotFound,
|
||
.BAD_NETWORK_PATH => return error.NetworkNotFound, // \\server was not found
|
||
.BAD_NETWORK_NAME => return error.NetworkNotFound, // \\server was found but \\server\share wasn't
|
||
.INVALID_PARAMETER => unreachable,
|
||
.FILE_IS_A_DIRECTORY => return error.IsDir,
|
||
.NOT_A_DIRECTORY => return error.NotDir,
|
||
.SHARING_VIOLATION => return error.FileBusy,
|
||
.ACCESS_DENIED => return error.AccessDenied,
|
||
.DELETE_PENDING => return,
|
||
else => return unexpectedStatus(rc),
|
||
}
|
||
defer CloseHandle(tmp_handle);
|
||
|
||
// FileDispositionInformationEx (and therefore FILE_DISPOSITION_POSIX_SEMANTICS and FILE_DISPOSITION_IGNORE_READONLY_ATTRIBUTE)
|
||
// are only supported on NTFS filesystems, so the version check on its own is only a partial solution. To support non-NTFS filesystems
|
||
// like FAT32, we need to fallback to FileDispositionInformation if the usage of FileDispositionInformationEx gives
|
||
// us INVALID_PARAMETER.
|
||
// The same reasoning for win10_rs5 as in os.renameatW() applies (FILE_DISPOSITION_IGNORE_READONLY_ATTRIBUTE requires >= win10_rs5).
|
||
var need_fallback = true;
|
||
if (comptime builtin.target.os.version_range.windows.min.isAtLeast(.win10_rs5)) {
|
||
// Deletion with posix semantics if the filesystem supports it.
|
||
var info = FILE_DISPOSITION_INFORMATION_EX{
|
||
.Flags = FILE_DISPOSITION_DELETE |
|
||
FILE_DISPOSITION_POSIX_SEMANTICS |
|
||
FILE_DISPOSITION_IGNORE_READONLY_ATTRIBUTE,
|
||
};
|
||
|
||
rc = ntdll.NtSetInformationFile(
|
||
tmp_handle,
|
||
&io,
|
||
&info,
|
||
@sizeOf(FILE_DISPOSITION_INFORMATION_EX),
|
||
.FileDispositionInformationEx,
|
||
);
|
||
switch (rc) {
|
||
.SUCCESS => return,
|
||
// INVALID_PARAMETER here means that the filesystem does not support FileDispositionInformationEx
|
||
.INVALID_PARAMETER => {},
|
||
// For all other statuses, fall down to the switch below to handle them.
|
||
else => need_fallback = false,
|
||
}
|
||
}
|
||
if (need_fallback) {
|
||
// Deletion with file pending semantics, which requires waiting or moving
|
||
// files to get them removed (from here).
|
||
var file_dispo = FILE_DISPOSITION_INFORMATION{
|
||
.DeleteFile = TRUE,
|
||
};
|
||
|
||
rc = ntdll.NtSetInformationFile(
|
||
tmp_handle,
|
||
&io,
|
||
&file_dispo,
|
||
@sizeOf(FILE_DISPOSITION_INFORMATION),
|
||
.FileDispositionInformation,
|
||
);
|
||
}
|
||
switch (rc) {
|
||
.SUCCESS => {},
|
||
.DIRECTORY_NOT_EMPTY => return error.DirNotEmpty,
|
||
.INVALID_PARAMETER => unreachable,
|
||
.CANNOT_DELETE => return error.AccessDenied,
|
||
.MEDIA_WRITE_PROTECTED => return error.AccessDenied,
|
||
.ACCESS_DENIED => return error.AccessDenied,
|
||
else => return unexpectedStatus(rc),
|
||
}
|
||
}
|
||
|
||
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(null, old_path);
|
||
const new_path_w = try sliceToPrefixedFileW(null, new_path);
|
||
return MoveFileExW(old_path_w.span().ptr, new_path_w.span().ptr, flags);
|
||
}
|
||
|
||
pub fn MoveFileExW(old_path: [*:0]const u16, new_path: [*:0]const u16, flags: DWORD) MoveFileError!void {
|
||
if (kernel32.MoveFileExW(old_path, new_path, flags) == 0) {
|
||
switch (GetLastError()) {
|
||
.FILE_NOT_FOUND => return error.FileNotFound,
|
||
.ACCESS_DENIED => return error.AccessDenied,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub const GetStdHandleError = error{
|
||
NoStandardHandleAttached,
|
||
Unexpected,
|
||
};
|
||
|
||
pub fn GetStdHandle(handle_id: DWORD) GetStdHandleError!HANDLE {
|
||
const handle = kernel32.GetStdHandle(handle_id) orelse return error.NoStandardHandleAttached;
|
||
if (handle == INVALID_HANDLE_VALUE) {
|
||
switch (GetLastError()) {
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
return handle;
|
||
}
|
||
|
||
pub const SetFilePointerError = error{Unexpected};
|
||
|
||
/// The SetFilePointerEx function with the `dwMoveMethod` parameter set to `FILE_BEGIN`.
|
||
pub fn SetFilePointerEx_BEGIN(handle: HANDLE, offset: u64) SetFilePointerError!void {
|
||
// "The starting point is zero or the beginning of the file. If [FILE_BEGIN]
|
||
// is specified, then the liDistanceToMove parameter is interpreted as an unsigned value."
|
||
// https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-setfilepointerex
|
||
const ipos = @as(LARGE_INTEGER, @bitCast(offset));
|
||
if (kernel32.SetFilePointerEx(handle, ipos, null, FILE_BEGIN) == 0) {
|
||
switch (GetLastError()) {
|
||
.INVALID_PARAMETER => unreachable,
|
||
.INVALID_HANDLE => unreachable,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// The SetFilePointerEx function with the `dwMoveMethod` parameter set to `FILE_CURRENT`.
|
||
pub fn SetFilePointerEx_CURRENT(handle: HANDLE, offset: i64) SetFilePointerError!void {
|
||
if (kernel32.SetFilePointerEx(handle, offset, null, FILE_CURRENT) == 0) {
|
||
switch (GetLastError()) {
|
||
.INVALID_PARAMETER => unreachable,
|
||
.INVALID_HANDLE => unreachable,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// The SetFilePointerEx function with the `dwMoveMethod` parameter set to `FILE_END`.
|
||
pub fn SetFilePointerEx_END(handle: HANDLE, offset: i64) SetFilePointerError!void {
|
||
if (kernel32.SetFilePointerEx(handle, offset, null, FILE_END) == 0) {
|
||
switch (GetLastError()) {
|
||
.INVALID_PARAMETER => unreachable,
|
||
.INVALID_HANDLE => unreachable,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// The SetFilePointerEx function with parameters to get the current offset.
|
||
pub fn SetFilePointerEx_CURRENT_get(handle: HANDLE) SetFilePointerError!u64 {
|
||
var result: LARGE_INTEGER = undefined;
|
||
if (kernel32.SetFilePointerEx(handle, 0, &result, FILE_CURRENT) == 0) {
|
||
switch (GetLastError()) {
|
||
.INVALID_PARAMETER => unreachable,
|
||
.INVALID_HANDLE => unreachable,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
// Based on the docs for FILE_BEGIN, it seems that the returned signed integer
|
||
// should be interpreted as an unsigned integer.
|
||
return @as(u64, @bitCast(result));
|
||
}
|
||
|
||
pub const QueryObjectNameError = error{
|
||
AccessDenied,
|
||
InvalidHandle,
|
||
NameTooLong,
|
||
Unexpected,
|
||
};
|
||
|
||
pub fn QueryObjectName(handle: HANDLE, out_buffer: []u16) QueryObjectNameError![]u16 {
|
||
const out_buffer_aligned = mem.alignInSlice(out_buffer, @alignOf(OBJECT_NAME_INFORMATION)) orelse return error.NameTooLong;
|
||
|
||
const info = @as(*OBJECT_NAME_INFORMATION, @ptrCast(out_buffer_aligned));
|
||
// buffer size is specified in bytes
|
||
const out_buffer_len = std.math.cast(ULONG, out_buffer_aligned.len * 2) orelse std.math.maxInt(ULONG);
|
||
// last argument would return the length required for full_buffer, not exposed here
|
||
return switch (ntdll.NtQueryObject(handle, .ObjectNameInformation, info, out_buffer_len, null)) {
|
||
.SUCCESS => blk: {
|
||
// info.Name.Buffer from ObQueryNameString is documented to be null (and MaximumLength == 0)
|
||
// if the object was "unnamed", not sure if this can happen for file handles
|
||
if (info.Name.MaximumLength == 0) break :blk error.Unexpected;
|
||
// resulting string length is specified in bytes
|
||
const path_length_unterminated = @divExact(info.Name.Length, 2);
|
||
break :blk info.Name.Buffer.?[0..path_length_unterminated];
|
||
},
|
||
.ACCESS_DENIED => error.AccessDenied,
|
||
.INVALID_HANDLE => error.InvalidHandle,
|
||
// triggered when the buffer is too small for the OBJECT_NAME_INFORMATION object (.INFO_LENGTH_MISMATCH),
|
||
// or if the buffer is too small for the file path returned (.BUFFER_OVERFLOW, .BUFFER_TOO_SMALL)
|
||
.INFO_LENGTH_MISMATCH, .BUFFER_OVERFLOW, .BUFFER_TOO_SMALL => error.NameTooLong,
|
||
else => |e| unexpectedStatus(e),
|
||
};
|
||
}
|
||
|
||
test QueryObjectName {
|
||
if (builtin.os.tag != .windows)
|
||
return;
|
||
|
||
//any file will do; canonicalization works on NTFS junctions and symlinks, hardlinks remain separate paths.
|
||
var tmp = std.testing.tmpDir(.{});
|
||
defer tmp.cleanup();
|
||
const handle = tmp.dir.fd;
|
||
var out_buffer: [PATH_MAX_WIDE]u16 = undefined;
|
||
|
||
const result_path = try QueryObjectName(handle, &out_buffer);
|
||
const required_len_in_u16 = result_path.len + @divExact(@intFromPtr(result_path.ptr) - @intFromPtr(&out_buffer), 2) + 1;
|
||
//insufficient size
|
||
try std.testing.expectError(error.NameTooLong, QueryObjectName(handle, out_buffer[0 .. required_len_in_u16 - 1]));
|
||
//exactly-sufficient size
|
||
_ = try QueryObjectName(handle, out_buffer[0..required_len_in_u16]);
|
||
}
|
||
|
||
pub const GetFinalPathNameByHandleError = error{
|
||
AccessDenied,
|
||
BadPathName,
|
||
FileNotFound,
|
||
NameTooLong,
|
||
/// The volume does not contain a recognized file system. File system
|
||
/// drivers might not be loaded, or the volume may be corrupt.
|
||
UnrecognizedVolume,
|
||
Unexpected,
|
||
};
|
||
|
||
/// Specifies how to format volume path in the result of `GetFinalPathNameByHandle`.
|
||
/// Defaults to DOS volume names.
|
||
pub const GetFinalPathNameByHandleFormat = struct {
|
||
volume_name: enum {
|
||
/// Format as DOS volume name
|
||
Dos,
|
||
/// Format as NT volume name
|
||
Nt,
|
||
} = .Dos,
|
||
};
|
||
|
||
/// Returns canonical (normalized) path of handle.
|
||
/// Use `GetFinalPathNameByHandleFormat` to specify whether the path is meant to include
|
||
/// NT or DOS volume name (e.g., `\Device\HarddiskVolume0\foo.txt` versus `C:\foo.txt`).
|
||
/// If DOS volume name format is selected, note that this function does *not* prepend
|
||
/// `\\?\` prefix to the resultant path.
|
||
pub fn GetFinalPathNameByHandle(
|
||
hFile: HANDLE,
|
||
fmt: GetFinalPathNameByHandleFormat,
|
||
out_buffer: []u16,
|
||
) GetFinalPathNameByHandleError![]u16 {
|
||
const final_path = QueryObjectName(hFile, out_buffer) catch |err| switch (err) {
|
||
// we assume InvalidHandle is close enough to FileNotFound in semantics
|
||
// to not further complicate the error set
|
||
error.InvalidHandle => return error.FileNotFound,
|
||
else => |e| return e,
|
||
};
|
||
|
||
switch (fmt.volume_name) {
|
||
.Nt => {
|
||
// the returned path is already in .Nt format
|
||
return final_path;
|
||
},
|
||
.Dos => {
|
||
// parse the string to separate volume path from file path
|
||
const expected_prefix = std.unicode.utf8ToUtf16LeStringLiteral("\\Device\\");
|
||
|
||
// TODO find out if a path can start with something besides `\Device\<volume name>`,
|
||
// and if we need to handle it differently
|
||
// (i.e. how to determine the start and end of the volume name in that case)
|
||
if (!mem.eql(u16, expected_prefix, final_path[0..expected_prefix.len])) return error.Unexpected;
|
||
|
||
const file_path_begin_index = mem.indexOfPos(u16, final_path, expected_prefix.len, &[_]u16{'\\'}) orelse unreachable;
|
||
const volume_name_u16 = final_path[0..file_path_begin_index];
|
||
const device_name_u16 = volume_name_u16[expected_prefix.len..];
|
||
const file_name_u16 = final_path[file_path_begin_index..];
|
||
|
||
// MUP is Multiple UNC Provider, and indicates that the path is a UNC
|
||
// path. In this case, the canonical UNC path can be gotten by just
|
||
// dropping the \Device\Mup\ and making sure the path begins with \\
|
||
if (mem.eql(u16, device_name_u16, std.unicode.utf8ToUtf16LeStringLiteral("Mup"))) {
|
||
out_buffer[0] = '\\';
|
||
mem.copyForwards(u16, out_buffer[1..][0..file_name_u16.len], file_name_u16);
|
||
return out_buffer[0 .. 1 + file_name_u16.len];
|
||
}
|
||
|
||
// Get DOS volume name. DOS volume names are actually symbolic link objects to the
|
||
// actual NT volume. For example:
|
||
// (NT) \Device\HarddiskVolume4 => (DOS) \DosDevices\C: == (DOS) C:
|
||
const MIN_SIZE = @sizeOf(MOUNTMGR_MOUNT_POINT) + MAX_PATH;
|
||
// We initialize the input buffer to all zeros for convenience since
|
||
// `DeviceIoControl` with `IOCTL_MOUNTMGR_QUERY_POINTS` expects this.
|
||
var input_buf: [MIN_SIZE]u8 align(@alignOf(MOUNTMGR_MOUNT_POINT)) = [_]u8{0} ** MIN_SIZE;
|
||
var output_buf: [MIN_SIZE * 4]u8 align(@alignOf(MOUNTMGR_MOUNT_POINTS)) = undefined;
|
||
|
||
// This surprising path is a filesystem path to the mount manager on Windows.
|
||
// Source: https://stackoverflow.com/questions/3012828/using-ioctl-mountmgr-query-points
|
||
// This is the NT namespaced version of \\.\MountPointManager
|
||
const mgmt_path_u16 = std.unicode.utf8ToUtf16LeStringLiteral("\\??\\MountPointManager");
|
||
const mgmt_handle = OpenFile(mgmt_path_u16, .{
|
||
.access_mask = SYNCHRONIZE,
|
||
.share_access = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
||
.creation = FILE_OPEN,
|
||
}) catch |err| switch (err) {
|
||
error.IsDir => return error.Unexpected,
|
||
error.NotDir => return error.Unexpected,
|
||
error.NoDevice => return error.Unexpected,
|
||
error.AccessDenied => return error.Unexpected,
|
||
error.PipeBusy => return error.Unexpected,
|
||
error.PathAlreadyExists => return error.Unexpected,
|
||
error.WouldBlock => return error.Unexpected,
|
||
error.NetworkNotFound => return error.Unexpected,
|
||
error.AntivirusInterference => return error.Unexpected,
|
||
else => |e| return e,
|
||
};
|
||
defer CloseHandle(mgmt_handle);
|
||
|
||
var input_struct: *MOUNTMGR_MOUNT_POINT = @ptrCast(&input_buf[0]);
|
||
input_struct.DeviceNameOffset = @sizeOf(MOUNTMGR_MOUNT_POINT);
|
||
input_struct.DeviceNameLength = @intCast(volume_name_u16.len * 2);
|
||
@memcpy(input_buf[@sizeOf(MOUNTMGR_MOUNT_POINT)..][0 .. volume_name_u16.len * 2], @as([*]const u8, @ptrCast(volume_name_u16.ptr)));
|
||
|
||
DeviceIoControl(mgmt_handle, IOCTL_MOUNTMGR_QUERY_POINTS, &input_buf, &output_buf) catch |err| switch (err) {
|
||
error.AccessDenied => return error.Unexpected,
|
||
else => |e| return e,
|
||
};
|
||
const mount_points_struct: *const MOUNTMGR_MOUNT_POINTS = @ptrCast(&output_buf[0]);
|
||
|
||
const mount_points = @as(
|
||
[*]const MOUNTMGR_MOUNT_POINT,
|
||
@ptrCast(&mount_points_struct.MountPoints[0]),
|
||
)[0..mount_points_struct.NumberOfMountPoints];
|
||
|
||
for (mount_points) |mount_point| {
|
||
const symlink = @as(
|
||
[*]const u16,
|
||
@ptrCast(@alignCast(&output_buf[mount_point.SymbolicLinkNameOffset])),
|
||
)[0 .. mount_point.SymbolicLinkNameLength / 2];
|
||
|
||
// Look for `\DosDevices\` prefix. We don't really care if there are more than one symlinks
|
||
// with traditional DOS drive letters, so pick the first one available.
|
||
var prefix_buf = std.unicode.utf8ToUtf16LeStringLiteral("\\DosDevices\\");
|
||
const prefix = prefix_buf[0..prefix_buf.len];
|
||
|
||
if (mem.startsWith(u16, symlink, prefix)) {
|
||
const drive_letter = symlink[prefix.len..];
|
||
|
||
if (out_buffer.len < drive_letter.len + file_name_u16.len) return error.NameTooLong;
|
||
|
||
@memcpy(out_buffer[0..drive_letter.len], drive_letter);
|
||
mem.copyForwards(u16, out_buffer[drive_letter.len..][0..file_name_u16.len], file_name_u16);
|
||
const total_len = drive_letter.len + file_name_u16.len;
|
||
|
||
// Validate that DOS does not contain any spurious nul bytes.
|
||
if (mem.indexOfScalar(u16, out_buffer[0..total_len], 0)) |_| {
|
||
return error.BadPathName;
|
||
}
|
||
|
||
return out_buffer[0..total_len];
|
||
} else if (mountmgrIsVolumeName(symlink)) {
|
||
// If the symlink is a volume GUID like \??\Volume{383da0b0-717f-41b6-8c36-00500992b58d},
|
||
// then it is a volume mounted as a path rather than a drive letter. We need to
|
||
// query the mount manager again to get the DOS path for the volume.
|
||
|
||
// 49 is the maximum length accepted by mountmgrIsVolumeName
|
||
const vol_input_size = @sizeOf(MOUNTMGR_TARGET_NAME) + (49 * 2);
|
||
var vol_input_buf: [vol_input_size]u8 align(@alignOf(MOUNTMGR_TARGET_NAME)) = [_]u8{0} ** vol_input_size;
|
||
// Note: If the path exceeds MAX_PATH, the Disk Management GUI doesn't accept the full path,
|
||
// and instead if must be specified using a shortened form (e.g. C:\FOO~1\BAR~1\<...>).
|
||
// However, just to be sure we can handle any path length, we use PATH_MAX_WIDE here.
|
||
const min_output_size = @sizeOf(MOUNTMGR_VOLUME_PATHS) + (PATH_MAX_WIDE * 2);
|
||
var vol_output_buf: [min_output_size]u8 align(@alignOf(MOUNTMGR_VOLUME_PATHS)) = undefined;
|
||
|
||
var vol_input_struct: *MOUNTMGR_TARGET_NAME = @ptrCast(&vol_input_buf[0]);
|
||
vol_input_struct.DeviceNameLength = @intCast(symlink.len * 2);
|
||
@memcpy(@as([*]WCHAR, &vol_input_struct.DeviceName)[0..symlink.len], symlink);
|
||
|
||
DeviceIoControl(mgmt_handle, IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH, &vol_input_buf, &vol_output_buf) catch |err| switch (err) {
|
||
error.AccessDenied => return error.Unexpected,
|
||
else => |e| return e,
|
||
};
|
||
const volume_paths_struct: *const MOUNTMGR_VOLUME_PATHS = @ptrCast(&vol_output_buf[0]);
|
||
const volume_path = std.mem.sliceTo(@as(
|
||
[*]const u16,
|
||
&volume_paths_struct.MultiSz,
|
||
)[0 .. volume_paths_struct.MultiSzLength / 2], 0);
|
||
|
||
if (out_buffer.len < volume_path.len + file_name_u16.len) return error.NameTooLong;
|
||
|
||
// `out_buffer` currently contains the memory of `file_name_u16`, so it can overlap with where
|
||
// we want to place the filename before returning. Here are the possible overlapping cases:
|
||
//
|
||
// out_buffer: [filename]
|
||
// dest: [___(a)___] [___(b)___]
|
||
//
|
||
// In the case of (a), we need to copy forwards, and in the case of (b) we need
|
||
// to copy backwards. We also need to do this before copying the volume path because
|
||
// it could overwrite the file_name_u16 memory.
|
||
const file_name_dest = out_buffer[volume_path.len..][0..file_name_u16.len];
|
||
const file_name_byte_offset = @intFromPtr(file_name_u16.ptr) - @intFromPtr(out_buffer.ptr);
|
||
const file_name_index = file_name_byte_offset / @sizeOf(u16);
|
||
if (volume_path.len > file_name_index)
|
||
mem.copyBackwards(u16, file_name_dest, file_name_u16)
|
||
else
|
||
mem.copyForwards(u16, file_name_dest, file_name_u16);
|
||
@memcpy(out_buffer[0..volume_path.len], volume_path);
|
||
const total_len = volume_path.len + file_name_u16.len;
|
||
|
||
// Validate that DOS does not contain any spurious nul bytes.
|
||
if (mem.indexOfScalar(u16, out_buffer[0..total_len], 0)) |_| {
|
||
return error.BadPathName;
|
||
}
|
||
|
||
return out_buffer[0..total_len];
|
||
}
|
||
}
|
||
|
||
// If we've ended up here, then something went wrong/is corrupted in the OS,
|
||
// so error out!
|
||
return error.FileNotFound;
|
||
},
|
||
}
|
||
}
|
||
|
||
/// Equivalent to the MOUNTMGR_IS_VOLUME_NAME macro in mountmgr.h
|
||
fn mountmgrIsVolumeName(name: []const u16) bool {
|
||
return (name.len == 48 or (name.len == 49 and name[48] == mem.nativeToLittle(u16, '\\'))) and
|
||
name[0] == mem.nativeToLittle(u16, '\\') and
|
||
(name[1] == mem.nativeToLittle(u16, '?') or name[1] == mem.nativeToLittle(u16, '\\')) and
|
||
name[2] == mem.nativeToLittle(u16, '?') and
|
||
name[3] == mem.nativeToLittle(u16, '\\') and
|
||
mem.startsWith(u16, name[4..], std.unicode.utf8ToUtf16LeStringLiteral("Volume{")) and
|
||
name[19] == mem.nativeToLittle(u16, '-') and
|
||
name[24] == mem.nativeToLittle(u16, '-') and
|
||
name[29] == mem.nativeToLittle(u16, '-') and
|
||
name[34] == mem.nativeToLittle(u16, '-') and
|
||
name[47] == mem.nativeToLittle(u16, '}');
|
||
}
|
||
|
||
test mountmgrIsVolumeName {
|
||
const L = std.unicode.utf8ToUtf16LeStringLiteral;
|
||
try std.testing.expect(mountmgrIsVolumeName(L("\\\\?\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}")));
|
||
try std.testing.expect(mountmgrIsVolumeName(L("\\??\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}")));
|
||
try std.testing.expect(mountmgrIsVolumeName(L("\\\\?\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}\\")));
|
||
try std.testing.expect(mountmgrIsVolumeName(L("\\??\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}\\")));
|
||
try std.testing.expect(!mountmgrIsVolumeName(L("\\\\.\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}")));
|
||
try std.testing.expect(!mountmgrIsVolumeName(L("\\??\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}\\foo")));
|
||
try std.testing.expect(!mountmgrIsVolumeName(L("\\??\\Volume{383da0b0-717f-41b6-8c36-00500992b58}")));
|
||
}
|
||
|
||
test GetFinalPathNameByHandle {
|
||
if (builtin.os.tag != .windows)
|
||
return;
|
||
|
||
//any file will do
|
||
var tmp = std.testing.tmpDir(.{});
|
||
defer tmp.cleanup();
|
||
const handle = tmp.dir.fd;
|
||
var buffer: [PATH_MAX_WIDE]u16 = undefined;
|
||
|
||
//check with sufficient size
|
||
const nt_path = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, &buffer);
|
||
_ = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Dos }, &buffer);
|
||
|
||
const required_len_in_u16 = nt_path.len + @divExact(@intFromPtr(nt_path.ptr) - @intFromPtr(&buffer), 2) + 1;
|
||
//check with insufficient size
|
||
try std.testing.expectError(error.NameTooLong, GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, buffer[0 .. required_len_in_u16 - 1]));
|
||
try std.testing.expectError(error.NameTooLong, GetFinalPathNameByHandle(handle, .{ .volume_name = .Dos }, buffer[0 .. required_len_in_u16 - 1]));
|
||
|
||
//check with exactly-sufficient size
|
||
_ = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, buffer[0..required_len_in_u16]);
|
||
_ = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Dos }, buffer[0..required_len_in_u16]);
|
||
}
|
||
|
||
pub const GetFileSizeError = error{Unexpected};
|
||
|
||
pub fn GetFileSizeEx(hFile: HANDLE) GetFileSizeError!u64 {
|
||
var file_size: LARGE_INTEGER = undefined;
|
||
if (kernel32.GetFileSizeEx(hFile, &file_size) == 0) {
|
||
switch (GetLastError()) {
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
return @as(u64, @bitCast(file_size));
|
||
}
|
||
|
||
pub const GetFileAttributesError = error{
|
||
FileNotFound,
|
||
PermissionDenied,
|
||
Unexpected,
|
||
};
|
||
|
||
pub fn GetFileAttributes(filename: []const u8) GetFileAttributesError!DWORD {
|
||
const filename_w = try sliceToPrefixedFileW(null, filename);
|
||
return GetFileAttributesW(filename_w.span().ptr);
|
||
}
|
||
|
||
pub fn GetFileAttributesW(lpFileName: [*:0]const u16) GetFileAttributesError!DWORD {
|
||
const rc = kernel32.GetFileAttributesW(lpFileName);
|
||
if (rc == INVALID_FILE_ATTRIBUTES) {
|
||
switch (GetLastError()) {
|
||
.FILE_NOT_FOUND => return error.FileNotFound,
|
||
.PATH_NOT_FOUND => return error.FileNotFound,
|
||
.ACCESS_DENIED => return error.PermissionDenied,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
return rc;
|
||
}
|
||
|
||
pub fn WSAStartup(majorVersion: u8, minorVersion: u8) !ws2_32.WSADATA {
|
||
var wsadata: ws2_32.WSADATA = undefined;
|
||
return switch (ws2_32.WSAStartup((@as(WORD, minorVersion) << 8) | majorVersion, &wsadata)) {
|
||
0 => wsadata,
|
||
else => |err_int| switch (@as(ws2_32.WinsockError, @enumFromInt(@as(u16, @intCast(err_int))))) {
|
||
.WSASYSNOTREADY => return error.SystemNotAvailable,
|
||
.WSAVERNOTSUPPORTED => return error.VersionNotSupported,
|
||
.WSAEINPROGRESS => return error.BlockingOperationInProgress,
|
||
.WSAEPROCLIM => return error.ProcessFdQuotaExceeded,
|
||
else => |err| return unexpectedWSAError(err),
|
||
},
|
||
};
|
||
}
|
||
|
||
pub fn WSACleanup() !void {
|
||
return switch (ws2_32.WSACleanup()) {
|
||
0 => {},
|
||
ws2_32.SOCKET_ERROR => switch (ws2_32.WSAGetLastError()) {
|
||
.WSANOTINITIALISED => return error.NotInitialized,
|
||
.WSAENETDOWN => return error.NetworkNotAvailable,
|
||
.WSAEINPROGRESS => return error.BlockingOperationInProgress,
|
||
else => |err| return unexpectedWSAError(err),
|
||
},
|
||
else => unreachable,
|
||
};
|
||
}
|
||
|
||
var wsa_startup_mutex: std.Thread.Mutex = .{};
|
||
|
||
pub fn callWSAStartup() !void {
|
||
wsa_startup_mutex.lock();
|
||
defer wsa_startup_mutex.unlock();
|
||
|
||
// Here we could use a flag to prevent multiple threads to prevent
|
||
// multiple calls to WSAStartup, but it doesn't matter. We're globally
|
||
// leaking the resource intentionally, and the mutex already prevents
|
||
// data races within the WSAStartup function.
|
||
_ = WSAStartup(2, 2) catch |err| switch (err) {
|
||
error.SystemNotAvailable => return error.SystemResources,
|
||
error.VersionNotSupported => return error.Unexpected,
|
||
error.BlockingOperationInProgress => return error.Unexpected,
|
||
error.ProcessFdQuotaExceeded => return error.ProcessFdQuotaExceeded,
|
||
error.Unexpected => return error.Unexpected,
|
||
};
|
||
}
|
||
|
||
/// Microsoft requires WSAStartup to be called to initialize, or else
|
||
/// WSASocketW will return WSANOTINITIALISED.
|
||
/// Since this is a standard library, we do not have the luxury of
|
||
/// putting initialization code anywhere, because we would not want
|
||
/// to pay the cost of calling WSAStartup if there ended up being no
|
||
/// networking. Also, if Zig code is used as a library, Zig is not in
|
||
/// charge of the start code, and we couldn't put in any initialization
|
||
/// code even if we wanted to.
|
||
/// The documentation for WSAStartup mentions that there must be a
|
||
/// matching WSACleanup call. It is not possible for the Zig Standard
|
||
/// Library to honor this for the same reason - there is nowhere to put
|
||
/// deinitialization code.
|
||
/// So, API users of the zig std lib have two options:
|
||
/// * (recommended) The simple, cross-platform way: just call `WSASocketW`
|
||
/// and don't worry about it. Zig will call WSAStartup() in a thread-safe
|
||
/// manner and never deinitialize networking. This is ideal for an
|
||
/// application which has the capability to do networking.
|
||
/// * The getting-your-hands-dirty way: call `WSAStartup()` before doing
|
||
/// networking, so that the error handling code for WSANOTINITIALISED never
|
||
/// gets run, which then allows the application or library to call `WSACleanup()`.
|
||
/// This could make sense for a library, which has init and deinit
|
||
/// functions for the whole library's lifetime.
|
||
pub fn WSASocketW(
|
||
af: i32,
|
||
socket_type: i32,
|
||
protocol: i32,
|
||
protocolInfo: ?*ws2_32.WSAPROTOCOL_INFOW,
|
||
g: ws2_32.GROUP,
|
||
dwFlags: DWORD,
|
||
) !ws2_32.SOCKET {
|
||
var first = true;
|
||
while (true) {
|
||
const rc = ws2_32.WSASocketW(af, socket_type, protocol, protocolInfo, g, dwFlags);
|
||
if (rc == ws2_32.INVALID_SOCKET) {
|
||
switch (ws2_32.WSAGetLastError()) {
|
||
.WSAEAFNOSUPPORT => return error.AddressFamilyNotSupported,
|
||
.WSAEMFILE => return error.ProcessFdQuotaExceeded,
|
||
.WSAENOBUFS => return error.SystemResources,
|
||
.WSAEPROTONOSUPPORT => return error.ProtocolNotSupported,
|
||
.WSANOTINITIALISED => {
|
||
if (!first) return error.Unexpected;
|
||
first = false;
|
||
try callWSAStartup();
|
||
continue;
|
||
},
|
||
else => |err| return unexpectedWSAError(err),
|
||
}
|
||
}
|
||
return rc;
|
||
}
|
||
}
|
||
|
||
pub fn bind(s: ws2_32.SOCKET, name: *const ws2_32.sockaddr, namelen: ws2_32.socklen_t) i32 {
|
||
return ws2_32.bind(s, name, @as(i32, @intCast(namelen)));
|
||
}
|
||
|
||
pub fn listen(s: ws2_32.SOCKET, backlog: u31) i32 {
|
||
return ws2_32.listen(s, backlog);
|
||
}
|
||
|
||
pub fn closesocket(s: ws2_32.SOCKET) !void {
|
||
switch (ws2_32.closesocket(s)) {
|
||
0 => {},
|
||
ws2_32.SOCKET_ERROR => switch (ws2_32.WSAGetLastError()) {
|
||
else => |err| return unexpectedWSAError(err),
|
||
},
|
||
else => unreachable,
|
||
}
|
||
}
|
||
|
||
pub fn accept(s: ws2_32.SOCKET, name: ?*ws2_32.sockaddr, namelen: ?*ws2_32.socklen_t) ws2_32.SOCKET {
|
||
assert((name == null) == (namelen == null));
|
||
return ws2_32.accept(s, name, @as(?*i32, @ptrCast(namelen)));
|
||
}
|
||
|
||
pub fn getsockname(s: ws2_32.SOCKET, name: *ws2_32.sockaddr, namelen: *ws2_32.socklen_t) i32 {
|
||
return ws2_32.getsockname(s, name, @as(*i32, @ptrCast(namelen)));
|
||
}
|
||
|
||
pub fn getpeername(s: ws2_32.SOCKET, name: *ws2_32.sockaddr, namelen: *ws2_32.socklen_t) i32 {
|
||
return ws2_32.getpeername(s, name, @as(*i32, @ptrCast(namelen)));
|
||
}
|
||
|
||
pub fn sendmsg(
|
||
s: ws2_32.SOCKET,
|
||
msg: *const ws2_32.WSAMSG,
|
||
flags: u32,
|
||
) i32 {
|
||
var bytes_send: DWORD = undefined;
|
||
if (ws2_32.WSASendMsg(s, msg, flags, &bytes_send, null, null) == ws2_32.SOCKET_ERROR) {
|
||
return ws2_32.SOCKET_ERROR;
|
||
} else {
|
||
return @as(i32, @as(u31, @intCast(bytes_send)));
|
||
}
|
||
}
|
||
|
||
pub fn sendto(s: ws2_32.SOCKET, buf: [*]const u8, len: usize, flags: u32, to: ?*const ws2_32.sockaddr, to_len: ws2_32.socklen_t) i32 {
|
||
var buffer = ws2_32.WSABUF{ .len = @as(u31, @truncate(len)), .buf = @constCast(buf) };
|
||
var bytes_send: DWORD = undefined;
|
||
if (ws2_32.WSASendTo(s, @as([*]ws2_32.WSABUF, @ptrCast(&buffer)), 1, &bytes_send, flags, to, @as(i32, @intCast(to_len)), null, null) == ws2_32.SOCKET_ERROR) {
|
||
return ws2_32.SOCKET_ERROR;
|
||
} else {
|
||
return @as(i32, @as(u31, @intCast(bytes_send)));
|
||
}
|
||
}
|
||
|
||
pub fn recvfrom(s: ws2_32.SOCKET, buf: [*]u8, len: usize, flags: u32, from: ?*ws2_32.sockaddr, from_len: ?*ws2_32.socklen_t) i32 {
|
||
var buffer = ws2_32.WSABUF{ .len = @as(u31, @truncate(len)), .buf = buf };
|
||
var bytes_received: DWORD = undefined;
|
||
var flags_inout = flags;
|
||
if (ws2_32.WSARecvFrom(s, @as([*]ws2_32.WSABUF, @ptrCast(&buffer)), 1, &bytes_received, &flags_inout, from, @as(?*i32, @ptrCast(from_len)), null, null) == ws2_32.SOCKET_ERROR) {
|
||
return ws2_32.SOCKET_ERROR;
|
||
} else {
|
||
return @as(i32, @as(u31, @intCast(bytes_received)));
|
||
}
|
||
}
|
||
|
||
pub fn poll(fds: [*]ws2_32.pollfd, n: c_ulong, timeout: i32) i32 {
|
||
return ws2_32.WSAPoll(fds, n, timeout);
|
||
}
|
||
|
||
pub fn WSAIoctl(
|
||
s: ws2_32.SOCKET,
|
||
dwIoControlCode: DWORD,
|
||
inBuffer: ?[]const u8,
|
||
outBuffer: []u8,
|
||
overlapped: ?*OVERLAPPED,
|
||
completionRoutine: ?ws2_32.LPWSAOVERLAPPED_COMPLETION_ROUTINE,
|
||
) !DWORD {
|
||
var bytes: DWORD = undefined;
|
||
switch (ws2_32.WSAIoctl(
|
||
s,
|
||
dwIoControlCode,
|
||
if (inBuffer) |i| i.ptr else null,
|
||
if (inBuffer) |i| @as(DWORD, @intCast(i.len)) else 0,
|
||
outBuffer.ptr,
|
||
@as(DWORD, @intCast(outBuffer.len)),
|
||
&bytes,
|
||
overlapped,
|
||
completionRoutine,
|
||
)) {
|
||
0 => {},
|
||
ws2_32.SOCKET_ERROR => switch (ws2_32.WSAGetLastError()) {
|
||
else => |err| return unexpectedWSAError(err),
|
||
},
|
||
else => unreachable,
|
||
}
|
||
return bytes;
|
||
}
|
||
|
||
const GetModuleFileNameError = error{Unexpected};
|
||
|
||
pub fn GetModuleFileNameW(hModule: ?HMODULE, buf_ptr: [*]u16, buf_len: DWORD) GetModuleFileNameError![:0]u16 {
|
||
const rc = kernel32.GetModuleFileNameW(hModule, buf_ptr, buf_len);
|
||
if (rc == 0) {
|
||
switch (GetLastError()) {
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
return buf_ptr[0..rc :0];
|
||
}
|
||
|
||
pub const TerminateProcessError = error{ PermissionDenied, Unexpected };
|
||
|
||
pub fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) TerminateProcessError!void {
|
||
if (kernel32.TerminateProcess(hProcess, uExitCode) == 0) {
|
||
switch (GetLastError()) {
|
||
Win32Error.ACCESS_DENIED => return error.PermissionDenied,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub const VirtualAllocError = error{Unexpected};
|
||
|
||
pub fn VirtualAlloc(addr: ?LPVOID, size: usize, alloc_type: DWORD, flProtect: DWORD) VirtualAllocError!LPVOID {
|
||
return kernel32.VirtualAlloc(addr, size, alloc_type, flProtect) orelse {
|
||
switch (GetLastError()) {
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
};
|
||
}
|
||
|
||
pub fn VirtualFree(lpAddress: ?LPVOID, dwSize: usize, dwFreeType: DWORD) void {
|
||
assert(kernel32.VirtualFree(lpAddress, dwSize, dwFreeType) != 0);
|
||
}
|
||
|
||
pub const VirtualProtectError = error{
|
||
InvalidAddress,
|
||
Unexpected,
|
||
};
|
||
|
||
pub fn VirtualProtect(lpAddress: ?LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: *DWORD) VirtualProtectError!void {
|
||
// ntdll takes an extra level of indirection here
|
||
var addr = lpAddress;
|
||
var size = dwSize;
|
||
switch (ntdll.NtProtectVirtualMemory(self_process_handle, &addr, &size, flNewProtect, lpflOldProtect)) {
|
||
.SUCCESS => {},
|
||
.INVALID_ADDRESS => return error.InvalidAddress,
|
||
else => |st| return unexpectedStatus(st),
|
||
}
|
||
}
|
||
|
||
pub fn VirtualProtectEx(handle: HANDLE, addr: ?LPVOID, size: SIZE_T, new_prot: DWORD) VirtualProtectError!DWORD {
|
||
var old_prot: DWORD = undefined;
|
||
var out_addr = addr;
|
||
var out_size = size;
|
||
switch (ntdll.NtProtectVirtualMemory(
|
||
handle,
|
||
&out_addr,
|
||
&out_size,
|
||
new_prot,
|
||
&old_prot,
|
||
)) {
|
||
.SUCCESS => return old_prot,
|
||
.INVALID_ADDRESS => return error.InvalidAddress,
|
||
// TODO: map errors
|
||
else => |rc| return unexpectedStatus(rc),
|
||
}
|
||
}
|
||
|
||
pub const VirtualQueryError = error{Unexpected};
|
||
|
||
pub fn VirtualQuery(lpAddress: ?LPVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T) VirtualQueryError!SIZE_T {
|
||
const rc = kernel32.VirtualQuery(lpAddress, lpBuffer, dwLength);
|
||
if (rc == 0) {
|
||
switch (GetLastError()) {
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
pub const SetConsoleTextAttributeError = error{Unexpected};
|
||
|
||
pub fn SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) SetConsoleTextAttributeError!void {
|
||
if (kernel32.SetConsoleTextAttribute(hConsoleOutput, wAttributes) == 0) {
|
||
switch (GetLastError()) {
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub fn SetConsoleCtrlHandler(handler_routine: ?HANDLER_ROUTINE, add: bool) !void {
|
||
const success = kernel32.SetConsoleCtrlHandler(
|
||
handler_routine,
|
||
if (add) TRUE else FALSE,
|
||
);
|
||
|
||
if (success == FALSE) {
|
||
return switch (GetLastError()) {
|
||
else => |err| unexpectedError(err),
|
||
};
|
||
}
|
||
}
|
||
|
||
pub fn SetFileCompletionNotificationModes(handle: HANDLE, flags: UCHAR) !void {
|
||
const success = kernel32.SetFileCompletionNotificationModes(handle, flags);
|
||
if (success == FALSE) {
|
||
return switch (GetLastError()) {
|
||
else => |err| unexpectedError(err),
|
||
};
|
||
}
|
||
}
|
||
|
||
pub const GetEnvironmentStringsError = error{OutOfMemory};
|
||
|
||
pub fn GetEnvironmentStringsW() GetEnvironmentStringsError![*:0]u16 {
|
||
return kernel32.GetEnvironmentStringsW() orelse return error.OutOfMemory;
|
||
}
|
||
|
||
pub fn FreeEnvironmentStringsW(penv: [*:0]u16) void {
|
||
assert(kernel32.FreeEnvironmentStringsW(penv) != 0);
|
||
}
|
||
|
||
pub const GetEnvironmentVariableError = error{
|
||
EnvironmentVariableNotFound,
|
||
Unexpected,
|
||
};
|
||
|
||
pub fn GetEnvironmentVariableW(lpName: LPWSTR, lpBuffer: [*]u16, nSize: DWORD) GetEnvironmentVariableError!DWORD {
|
||
const rc = kernel32.GetEnvironmentVariableW(lpName, lpBuffer, nSize);
|
||
if (rc == 0) {
|
||
switch (GetLastError()) {
|
||
.ENVVAR_NOT_FOUND => return error.EnvironmentVariableNotFound,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
return rc;
|
||
}
|
||
|
||
pub const CreateProcessError = error{
|
||
FileNotFound,
|
||
AccessDenied,
|
||
InvalidName,
|
||
NameTooLong,
|
||
InvalidExe,
|
||
Unexpected,
|
||
};
|
||
|
||
pub fn CreateProcessW(
|
||
lpApplicationName: ?LPCWSTR,
|
||
lpCommandLine: ?LPWSTR,
|
||
lpProcessAttributes: ?*SECURITY_ATTRIBUTES,
|
||
lpThreadAttributes: ?*SECURITY_ATTRIBUTES,
|
||
bInheritHandles: BOOL,
|
||
dwCreationFlags: DWORD,
|
||
lpEnvironment: ?*anyopaque,
|
||
lpCurrentDirectory: ?LPCWSTR,
|
||
lpStartupInfo: *STARTUPINFOW,
|
||
lpProcessInformation: *PROCESS_INFORMATION,
|
||
) CreateProcessError!void {
|
||
if (kernel32.CreateProcessW(
|
||
lpApplicationName,
|
||
lpCommandLine,
|
||
lpProcessAttributes,
|
||
lpThreadAttributes,
|
||
bInheritHandles,
|
||
dwCreationFlags,
|
||
lpEnvironment,
|
||
lpCurrentDirectory,
|
||
lpStartupInfo,
|
||
lpProcessInformation,
|
||
) == 0) {
|
||
switch (GetLastError()) {
|
||
.FILE_NOT_FOUND => return error.FileNotFound,
|
||
.PATH_NOT_FOUND => return error.FileNotFound,
|
||
.ACCESS_DENIED => return error.AccessDenied,
|
||
.INVALID_PARAMETER => unreachable,
|
||
.INVALID_NAME => return error.InvalidName,
|
||
.FILENAME_EXCED_RANGE => return error.NameTooLong,
|
||
// These are all the system errors that are mapped to ENOEXEC by
|
||
// the undocumented _dosmaperr (old CRT) or __acrt_errno_map_os_error
|
||
// (newer CRT) functions. Their code can be found in crt/src/dosmap.c (old SDK)
|
||
// or urt/misc/errno.cpp (newer SDK) in the Windows SDK.
|
||
.BAD_FORMAT,
|
||
.INVALID_STARTING_CODESEG, // MIN_EXEC_ERROR in errno.cpp
|
||
.INVALID_STACKSEG,
|
||
.INVALID_MODULETYPE,
|
||
.INVALID_EXE_SIGNATURE,
|
||
.EXE_MARKED_INVALID,
|
||
.BAD_EXE_FORMAT,
|
||
.ITERATED_DATA_EXCEEDS_64k,
|
||
.INVALID_MINALLOCSIZE,
|
||
.DYNLINK_FROM_INVALID_RING,
|
||
.IOPL_NOT_ENABLED,
|
||
.INVALID_SEGDPL,
|
||
.AUTODATASEG_EXCEEDS_64k,
|
||
.RING2SEG_MUST_BE_MOVABLE,
|
||
.RELOC_CHAIN_XEEDS_SEGLIM,
|
||
.INFLOOP_IN_RELOC_CHAIN, // MAX_EXEC_ERROR in errno.cpp
|
||
// This one is not mapped to ENOEXEC but it is possible, for example
|
||
// when calling CreateProcessW on a plain text file with a .exe extension
|
||
.EXE_MACHINE_TYPE_MISMATCH,
|
||
=> return error.InvalidExe,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub const LoadLibraryError = error{
|
||
FileNotFound,
|
||
Unexpected,
|
||
};
|
||
|
||
pub fn LoadLibraryW(lpLibFileName: [*:0]const u16) LoadLibraryError!HMODULE {
|
||
return kernel32.LoadLibraryW(lpLibFileName) orelse {
|
||
switch (GetLastError()) {
|
||
.FILE_NOT_FOUND => return error.FileNotFound,
|
||
.PATH_NOT_FOUND => return error.FileNotFound,
|
||
.MOD_NOT_FOUND => return error.FileNotFound,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
};
|
||
}
|
||
|
||
pub const LoadLibraryFlags = enum(DWORD) {
|
||
none = 0,
|
||
dont_resolve_dll_references = 0x00000001,
|
||
load_ignore_code_authz_level = 0x00000010,
|
||
load_library_as_datafile = 0x00000002,
|
||
load_library_as_datafile_exclusive = 0x00000040,
|
||
load_library_as_image_resource = 0x00000020,
|
||
load_library_search_application_dir = 0x00000200,
|
||
load_library_search_default_dirs = 0x00001000,
|
||
load_library_search_dll_load_dir = 0x00000100,
|
||
load_library_search_system32 = 0x00000800,
|
||
load_library_search_user_dirs = 0x00000400,
|
||
load_with_altered_search_path = 0x00000008,
|
||
load_library_require_signed_target = 0x00000080,
|
||
load_library_safe_current_dirs = 0x00002000,
|
||
};
|
||
|
||
pub fn LoadLibraryExW(lpLibFileName: [*:0]const u16, dwFlags: LoadLibraryFlags) LoadLibraryError!HMODULE {
|
||
return kernel32.LoadLibraryExW(lpLibFileName, null, @intFromEnum(dwFlags)) orelse {
|
||
switch (GetLastError()) {
|
||
.FILE_NOT_FOUND => return error.FileNotFound,
|
||
.PATH_NOT_FOUND => return error.FileNotFound,
|
||
.MOD_NOT_FOUND => return error.FileNotFound,
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
};
|
||
}
|
||
|
||
pub fn FreeLibrary(hModule: HMODULE) void {
|
||
assert(kernel32.FreeLibrary(hModule) != 0);
|
||
}
|
||
|
||
pub fn QueryPerformanceFrequency() u64 {
|
||
// "On systems that run Windows XP or later, the function will always succeed"
|
||
// https://docs.microsoft.com/en-us/windows/desktop/api/profileapi/nf-profileapi-queryperformancefrequency
|
||
var result: LARGE_INTEGER = undefined;
|
||
assert(ntdll.RtlQueryPerformanceFrequency(&result) != 0);
|
||
// The kernel treats this integer as unsigned.
|
||
return @as(u64, @bitCast(result));
|
||
}
|
||
|
||
pub fn QueryPerformanceCounter() u64 {
|
||
// "On systems that run Windows XP or later, the function will always succeed"
|
||
// https://docs.microsoft.com/en-us/windows/desktop/api/profileapi/nf-profileapi-queryperformancecounter
|
||
var result: LARGE_INTEGER = undefined;
|
||
assert(ntdll.RtlQueryPerformanceCounter(&result) != 0);
|
||
// The kernel treats this integer as unsigned.
|
||
return @as(u64, @bitCast(result));
|
||
}
|
||
|
||
pub fn InitOnceExecuteOnce(InitOnce: *INIT_ONCE, InitFn: INIT_ONCE_FN, Parameter: ?*anyopaque, Context: ?*anyopaque) void {
|
||
assert(kernel32.InitOnceExecuteOnce(InitOnce, InitFn, Parameter, Context) != 0);
|
||
}
|
||
|
||
pub fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: *anyopaque) void {
|
||
assert(kernel32.HeapFree(hHeap, dwFlags, lpMem) != 0);
|
||
}
|
||
|
||
pub fn HeapDestroy(hHeap: HANDLE) void {
|
||
assert(kernel32.HeapDestroy(hHeap) != 0);
|
||
}
|
||
|
||
pub fn LocalFree(hMem: HLOCAL) void {
|
||
assert(kernel32.LocalFree(hMem) == null);
|
||
}
|
||
|
||
pub const SetFileTimeError = error{Unexpected};
|
||
|
||
pub fn SetFileTime(
|
||
hFile: HANDLE,
|
||
lpCreationTime: ?*const FILETIME,
|
||
lpLastAccessTime: ?*const FILETIME,
|
||
lpLastWriteTime: ?*const FILETIME,
|
||
) SetFileTimeError!void {
|
||
const rc = kernel32.SetFileTime(hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
|
||
if (rc == 0) {
|
||
switch (GetLastError()) {
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub const LockFileError = error{
|
||
SystemResources,
|
||
WouldBlock,
|
||
} || UnexpectedError;
|
||
|
||
pub fn LockFile(
|
||
FileHandle: HANDLE,
|
||
Event: ?HANDLE,
|
||
ApcRoutine: ?*IO_APC_ROUTINE,
|
||
ApcContext: ?*anyopaque,
|
||
IoStatusBlock: *IO_STATUS_BLOCK,
|
||
ByteOffset: *const LARGE_INTEGER,
|
||
Length: *const LARGE_INTEGER,
|
||
Key: ?*ULONG,
|
||
FailImmediately: BOOLEAN,
|
||
ExclusiveLock: BOOLEAN,
|
||
) !void {
|
||
const rc = ntdll.NtLockFile(
|
||
FileHandle,
|
||
Event,
|
||
ApcRoutine,
|
||
ApcContext,
|
||
IoStatusBlock,
|
||
ByteOffset,
|
||
Length,
|
||
Key,
|
||
FailImmediately,
|
||
ExclusiveLock,
|
||
);
|
||
switch (rc) {
|
||
.SUCCESS => return,
|
||
.INSUFFICIENT_RESOURCES => return error.SystemResources,
|
||
.LOCK_NOT_GRANTED => return error.WouldBlock,
|
||
.ACCESS_VIOLATION => unreachable, // bad io_status_block pointer
|
||
else => return unexpectedStatus(rc),
|
||
}
|
||
}
|
||
|
||
pub const UnlockFileError = error{
|
||
RangeNotLocked,
|
||
} || UnexpectedError;
|
||
|
||
pub fn UnlockFile(
|
||
FileHandle: HANDLE,
|
||
IoStatusBlock: *IO_STATUS_BLOCK,
|
||
ByteOffset: *const LARGE_INTEGER,
|
||
Length: *const LARGE_INTEGER,
|
||
Key: ?*ULONG,
|
||
) !void {
|
||
const rc = ntdll.NtUnlockFile(FileHandle, IoStatusBlock, ByteOffset, Length, Key);
|
||
switch (rc) {
|
||
.SUCCESS => return,
|
||
.RANGE_NOT_LOCKED => return error.RangeNotLocked,
|
||
.ACCESS_VIOLATION => unreachable, // bad io_status_block pointer
|
||
else => return unexpectedStatus(rc),
|
||
}
|
||
}
|
||
|
||
/// This is a workaround for the C backend until zig has the ability to put
|
||
/// C code in inline assembly.
|
||
extern fn zig_x86_windows_teb() callconv(.C) *anyopaque;
|
||
extern fn zig_x86_64_windows_teb() callconv(.C) *anyopaque;
|
||
|
||
pub fn teb() *TEB {
|
||
return switch (native_arch) {
|
||
.x86 => blk: {
|
||
if (builtin.zig_backend == .stage2_c) {
|
||
break :blk @ptrCast(@alignCast(zig_x86_windows_teb()));
|
||
} else {
|
||
break :blk asm (
|
||
\\ movl %%fs:0x18, %[ptr]
|
||
: [ptr] "=r" (-> *TEB),
|
||
);
|
||
}
|
||
},
|
||
.x86_64 => blk: {
|
||
if (builtin.zig_backend == .stage2_c) {
|
||
break :blk @ptrCast(@alignCast(zig_x86_64_windows_teb()));
|
||
} else {
|
||
break :blk asm (
|
||
\\ movq %%gs:0x30, %[ptr]
|
||
: [ptr] "=r" (-> *TEB),
|
||
);
|
||
}
|
||
},
|
||
.thumb => asm (
|
||
\\ mrc p15, 0, %[ptr], c13, c0, 2
|
||
: [ptr] "=r" (-> *TEB),
|
||
),
|
||
.aarch64 => asm (
|
||
\\ mov %[ptr], x18
|
||
: [ptr] "=r" (-> *TEB),
|
||
),
|
||
else => @compileError("unsupported arch"),
|
||
};
|
||
}
|
||
|
||
pub fn peb() *PEB {
|
||
return teb().ProcessEnvironmentBlock;
|
||
}
|
||
|
||
/// A file time is a 64-bit value that represents the number of 100-nanosecond
|
||
/// intervals that have elapsed since 12:00 A.M. January 1, 1601 Coordinated
|
||
/// Universal Time (UTC).
|
||
/// This function returns the number of nanoseconds since the canonical epoch,
|
||
/// which is the POSIX one (Jan 01, 1970 AD).
|
||
pub fn fromSysTime(hns: i64) i128 {
|
||
const adjusted_epoch: i128 = hns + std.time.epoch.windows * (std.time.ns_per_s / 100);
|
||
return adjusted_epoch * 100;
|
||
}
|
||
|
||
pub fn toSysTime(ns: i128) i64 {
|
||
const hns = @divFloor(ns, 100);
|
||
return @as(i64, @intCast(hns)) - std.time.epoch.windows * (std.time.ns_per_s / 100);
|
||
}
|
||
|
||
pub fn fileTimeToNanoSeconds(ft: FILETIME) i128 {
|
||
const hns = (@as(i64, ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
|
||
return fromSysTime(hns);
|
||
}
|
||
|
||
/// Converts a number of nanoseconds since the POSIX epoch to a Windows FILETIME.
|
||
pub fn nanoSecondsToFileTime(ns: i128) FILETIME {
|
||
const adjusted: u64 = @bitCast(toSysTime(ns));
|
||
return FILETIME{
|
||
.dwHighDateTime = @as(u32, @truncate(adjusted >> 32)),
|
||
.dwLowDateTime = @as(u32, @truncate(adjusted)),
|
||
};
|
||
}
|
||
|
||
/// Compares two WTF16 strings using the equivalent functionality of
|
||
/// `RtlEqualUnicodeString` (with case insensitive comparison enabled).
|
||
/// This function can be called on any target.
|
||
pub fn eqlIgnoreCaseWTF16(a: []const u16, b: []const u16) bool {
|
||
if (@inComptime() or builtin.os.tag != .windows) {
|
||
// This function compares the strings code unit by code unit (aka u16-to-u16),
|
||
// so any length difference implies inequality. In other words, there's no possible
|
||
// conversion that changes the number of WTF-16 code units needed for the uppercase/lowercase
|
||
// version in the conversion table since only codepoints <= max(u16) are eligible
|
||
// for conversion at all.
|
||
if (a.len != b.len) return false;
|
||
|
||
for (a, b) |a_c, b_c| {
|
||
// The slices are always WTF-16 LE, so need to convert the elements to native
|
||
// endianness for the uppercasing
|
||
const a_c_native = std.mem.littleToNative(u16, a_c);
|
||
const b_c_native = std.mem.littleToNative(u16, b_c);
|
||
if (a_c != b_c and nls.upcaseW(a_c_native) != nls.upcaseW(b_c_native)) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
// Use RtlEqualUnicodeString on Windows when not in comptime to avoid including a
|
||
// redundant copy of the uppercase data.
|
||
const a_bytes = @as(u16, @intCast(a.len * 2));
|
||
const a_string = UNICODE_STRING{
|
||
.Length = a_bytes,
|
||
.MaximumLength = a_bytes,
|
||
.Buffer = @constCast(a.ptr),
|
||
};
|
||
const b_bytes = @as(u16, @intCast(b.len * 2));
|
||
const b_string = UNICODE_STRING{
|
||
.Length = b_bytes,
|
||
.MaximumLength = b_bytes,
|
||
.Buffer = @constCast(b.ptr),
|
||
};
|
||
return ntdll.RtlEqualUnicodeString(&a_string, &b_string, TRUE) == TRUE;
|
||
}
|
||
|
||
/// Compares two WTF-8 strings using the equivalent functionality of
|
||
/// `RtlEqualUnicodeString` (with case insensitive comparison enabled).
|
||
/// This function can be called on any target.
|
||
/// Assumes `a` and `b` are valid WTF-8.
|
||
pub fn eqlIgnoreCaseWtf8(a: []const u8, b: []const u8) bool {
|
||
// A length equality check is not possible here because there are
|
||
// some codepoints that have a different length uppercase UTF-8 representations
|
||
// than their lowercase counterparts, e.g. U+0250 (2 bytes) <-> U+2C6F (3 bytes).
|
||
// There are 7 such codepoints in the uppercase data used by Windows.
|
||
|
||
var a_wtf8_it = std.unicode.Wtf8View.initUnchecked(a).iterator();
|
||
var b_wtf8_it = std.unicode.Wtf8View.initUnchecked(b).iterator();
|
||
|
||
// Use RtlUpcaseUnicodeChar on Windows when not in comptime to avoid including a
|
||
// redundant copy of the uppercase data.
|
||
const upcaseImpl = switch (builtin.os.tag) {
|
||
.windows => if (@inComptime()) nls.upcaseW else ntdll.RtlUpcaseUnicodeChar,
|
||
else => nls.upcaseW,
|
||
};
|
||
|
||
while (true) {
|
||
const a_cp = a_wtf8_it.nextCodepoint() orelse break;
|
||
const b_cp = b_wtf8_it.nextCodepoint() orelse return false;
|
||
|
||
if (a_cp <= std.math.maxInt(u16) and b_cp <= std.math.maxInt(u16)) {
|
||
if (a_cp != b_cp and upcaseImpl(@intCast(a_cp)) != upcaseImpl(@intCast(b_cp))) {
|
||
return false;
|
||
}
|
||
} else if (a_cp != b_cp) {
|
||
return false;
|
||
}
|
||
}
|
||
// Make sure there are no leftover codepoints in b
|
||
if (b_wtf8_it.nextCodepoint() != null) return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
fn testEqlIgnoreCase(comptime expect_eql: bool, comptime a: []const u8, comptime b: []const u8) !void {
|
||
try std.testing.expectEqual(expect_eql, eqlIgnoreCaseWtf8(a, b));
|
||
try std.testing.expectEqual(expect_eql, eqlIgnoreCaseWTF16(
|
||
std.unicode.utf8ToUtf16LeStringLiteral(a),
|
||
std.unicode.utf8ToUtf16LeStringLiteral(b),
|
||
));
|
||
|
||
try comptime std.testing.expect(expect_eql == eqlIgnoreCaseWtf8(a, b));
|
||
try comptime std.testing.expect(expect_eql == eqlIgnoreCaseWTF16(
|
||
std.unicode.utf8ToUtf16LeStringLiteral(a),
|
||
std.unicode.utf8ToUtf16LeStringLiteral(b),
|
||
));
|
||
}
|
||
|
||
test "eqlIgnoreCaseWTF16/Wtf8" {
|
||
try testEqlIgnoreCase(true, "\x01 a B Λ ɐ", "\x01 A b λ Ɐ");
|
||
// does not do case-insensitive comparison for codepoints >= U+10000
|
||
try testEqlIgnoreCase(false, "𐓏", "𐓷");
|
||
}
|
||
|
||
pub const PathSpace = struct {
|
||
data: [PATH_MAX_WIDE:0]u16,
|
||
len: usize,
|
||
|
||
pub fn span(self: *const PathSpace) [:0]const u16 {
|
||
return self.data[0..self.len :0];
|
||
}
|
||
};
|
||
|
||
/// The error type for `removeDotDirsSanitized`
|
||
pub const RemoveDotDirsError = error{TooManyParentDirs};
|
||
|
||
/// Removes '.' and '..' path components from a "sanitized relative path".
|
||
/// A "sanitized path" is one where:
|
||
/// 1) all forward slashes have been replaced with back slashes
|
||
/// 2) all repeating back slashes have been collapsed
|
||
/// 3) the path is a relative one (does not start with a back slash)
|
||
pub fn removeDotDirsSanitized(comptime T: type, path: []T) RemoveDotDirsError!usize {
|
||
std.debug.assert(path.len == 0 or path[0] != '\\');
|
||
|
||
var write_idx: usize = 0;
|
||
var read_idx: usize = 0;
|
||
while (read_idx < path.len) {
|
||
if (path[read_idx] == '.') {
|
||
if (read_idx + 1 == path.len)
|
||
return write_idx;
|
||
|
||
const after_dot = path[read_idx + 1];
|
||
if (after_dot == '\\') {
|
||
read_idx += 2;
|
||
continue;
|
||
}
|
||
if (after_dot == '.' and (read_idx + 2 == path.len or path[read_idx + 2] == '\\')) {
|
||
if (write_idx == 0) return error.TooManyParentDirs;
|
||
std.debug.assert(write_idx >= 2);
|
||
write_idx -= 1;
|
||
while (true) {
|
||
write_idx -= 1;
|
||
if (write_idx == 0) break;
|
||
if (path[write_idx] == '\\') {
|
||
write_idx += 1;
|
||
break;
|
||
}
|
||
}
|
||
if (read_idx + 2 == path.len)
|
||
return write_idx;
|
||
read_idx += 3;
|
||
continue;
|
||
}
|
||
}
|
||
|
||
// skip to the next path separator
|
||
while (true) : (read_idx += 1) {
|
||
if (read_idx == path.len)
|
||
return write_idx;
|
||
path[write_idx] = path[read_idx];
|
||
write_idx += 1;
|
||
if (path[read_idx] == '\\')
|
||
break;
|
||
}
|
||
read_idx += 1;
|
||
}
|
||
return write_idx;
|
||
}
|
||
|
||
/// Normalizes a Windows path with the following steps:
|
||
/// 1) convert all forward slashes to back slashes
|
||
/// 2) collapse duplicate back slashes
|
||
/// 3) remove '.' and '..' directory parts
|
||
/// Returns the length of the new path.
|
||
pub fn normalizePath(comptime T: type, path: []T) RemoveDotDirsError!usize {
|
||
mem.replaceScalar(T, path, '/', '\\');
|
||
const new_len = mem.collapseRepeatsLen(T, path, '\\');
|
||
|
||
const prefix_len: usize = init: {
|
||
if (new_len >= 1 and path[0] == '\\') break :init 1;
|
||
if (new_len >= 2 and path[1] == ':')
|
||
break :init if (new_len >= 3 and path[2] == '\\') @as(usize, 3) else @as(usize, 2);
|
||
break :init 0;
|
||
};
|
||
|
||
return prefix_len + try removeDotDirsSanitized(T, path[prefix_len..new_len]);
|
||
}
|
||
|
||
pub const Wtf8ToPrefixedFileWError = error{InvalidWtf8} || Wtf16ToPrefixedFileWError;
|
||
|
||
/// Same as `sliceToPrefixedFileW` but accepts a pointer
|
||
/// to a null-terminated WTF-8 encoded path.
|
||
/// https://simonsapin.github.io/wtf-8/
|
||
pub fn cStrToPrefixedFileW(dir: ?HANDLE, s: [*:0]const u8) Wtf8ToPrefixedFileWError!PathSpace {
|
||
return sliceToPrefixedFileW(dir, mem.sliceTo(s, 0));
|
||
}
|
||
|
||
/// Same as `wToPrefixedFileW` but accepts a WTF-8 encoded path.
|
||
/// https://simonsapin.github.io/wtf-8/
|
||
pub fn sliceToPrefixedFileW(dir: ?HANDLE, path: []const u8) Wtf8ToPrefixedFileWError!PathSpace {
|
||
var temp_path: PathSpace = undefined;
|
||
temp_path.len = try std.unicode.wtf8ToWtf16Le(&temp_path.data, path);
|
||
temp_path.data[temp_path.len] = 0;
|
||
return wToPrefixedFileW(dir, temp_path.span());
|
||
}
|
||
|
||
pub const Wtf16ToPrefixedFileWError = error{
|
||
AccessDenied,
|
||
BadPathName,
|
||
FileNotFound,
|
||
NameTooLong,
|
||
Unexpected,
|
||
};
|
||
|
||
/// Converts the `path` to WTF16, null-terminated. If the path contains any
|
||
/// namespace prefix, or is anything but a relative path (rooted, drive relative,
|
||
/// etc) the result will have the NT-style prefix `\??\`.
|
||
///
|
||
/// 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 resolved against the `dir` if it
|
||
/// 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(dir: ?HANDLE, path: [:0]const u16) Wtf16ToPrefixedFileWError!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,
|
||
// since it is always returned fully unmodified.
|
||
.nt, .verbatim => {
|
||
var path_space: PathSpace = undefined;
|
||
path_space.data[0..nt_prefix.len].* = nt_prefix;
|
||
const len_after_prefix = path.len - nt_prefix.len;
|
||
@memcpy(path_space.data[nt_prefix.len..][0..len_after_prefix], path[nt_prefix.len..]);
|
||
path_space.len = path.len;
|
||
path_space.data[path_space.len] = 0;
|
||
return path_space;
|
||
},
|
||
.local_device, .fake_verbatim => {
|
||
var path_space: PathSpace = undefined;
|
||
const path_byte_len = ntdll.RtlGetFullPathName_U(
|
||
path.ptr,
|
||
path_space.data.len * 2,
|
||
&path_space.data,
|
||
null,
|
||
);
|
||
if (path_byte_len == 0) {
|
||
// TODO: This may not be the right error
|
||
return error.BadPathName;
|
||
} else if (path_byte_len / 2 > path_space.data.len) {
|
||
return error.NameTooLong;
|
||
}
|
||
path_space.len = path_byte_len / 2;
|
||
// Both prefixes will be normalized but retained, so all
|
||
// we need to do now is replace them with the NT prefix
|
||
path_space.data[0..nt_prefix.len].* = nt_prefix;
|
||
return path_space;
|
||
},
|
||
.none => {
|
||
const path_type = getUnprefixedPathType(u16, path);
|
||
var path_space: PathSpace = undefined;
|
||
relative: {
|
||
if (path_type == .relative) {
|
||
// TODO: Handle special case device names like COM1, AUX, NUL, CONIN$, CONOUT$, etc.
|
||
// See https://googleprojectzero.blogspot.com/2016/02/the-definitive-guide-on-win32-to-nt.html
|
||
|
||
// TODO: Potentially strip all trailing . and space characters from the
|
||
// end of the path. This is something that both RtlDosPathNameToNtPathName_U
|
||
// and RtlGetFullPathName_U do. Technically, trailing . and spaces
|
||
// are allowed, but such paths may not interact well with Windows (i.e.
|
||
// files with these paths can't be deleted from explorer.exe, etc).
|
||
// This could be something that normalizePath may want to do.
|
||
|
||
@memcpy(path_space.data[0..path.len], path);
|
||
// Try to normalize, but if we get too many parent directories,
|
||
// then we need to 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,
|
||
};
|
||
path_space.data[path_space.len] = 0;
|
||
return path_space;
|
||
}
|
||
}
|
||
// We now know we are going to return an absolute NT path, so
|
||
// we can unconditionally prefix it with the NT prefix.
|
||
path_space.data[0..nt_prefix.len].* = nt_prefix;
|
||
if (path_type == .root_local_device) {
|
||
// `\\.` and `\\?` always get converted to `\??\` exactly, so
|
||
// we can just stop here
|
||
path_space.len = nt_prefix.len;
|
||
path_space.data[path_space.len] = 0;
|
||
return path_space;
|
||
}
|
||
const path_buf_offset = switch (path_type) {
|
||
// UNC paths will always start with `\\`. However, we want to
|
||
// end up with something like `\??\UNC\server\share`, so to get
|
||
// RtlGetFullPathName to write into the spot we want the `server`
|
||
// part to end up, we need to provide an offset such that
|
||
// the `\\` part gets written where the `C\` of `UNC\` will be
|
||
// in the final NT path.
|
||
.unc_absolute => nt_prefix.len + 2,
|
||
else => nt_prefix.len,
|
||
};
|
||
const buf_len: 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 = GetFinalPathNameByHandle(dir.?, .{}, &dir_path_buf) catch |err| switch (err) {
|
||
// This mapping is not correct; it is actually expected
|
||
// that calling GetFinalPathNameByHandle might return
|
||
// error.UnrecognizedVolume, and in fact has been observed
|
||
// in the wild. The problem is that wToPrefixedFileW was
|
||
// never intended to make *any* OS syscall APIs. It's only
|
||
// supposed to convert a string to one that is eligible to
|
||
// be used in the ntdll syscalls.
|
||
//
|
||
// To solve this, this function needs to no longer call
|
||
// GetFinalPathNameByHandle under any conditions, or the
|
||
// calling function needs to get reworked to not need to
|
||
// call this function.
|
||
//
|
||
// This may involve making breaking API changes.
|
||
error.UnrecognizedVolume => return error.Unexpected,
|
||
else => |e| return e,
|
||
};
|
||
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_to_get.ptr,
|
||
buf_len * 2,
|
||
path_space.data[path_buf_offset..].ptr,
|
||
null,
|
||
);
|
||
if (path_byte_len == 0) {
|
||
// TODO: This may not be the right error
|
||
return error.BadPathName;
|
||
} else if (path_byte_len / 2 > buf_len) {
|
||
return error.NameTooLong;
|
||
}
|
||
path_space.len = path_buf_offset + (path_byte_len / 2);
|
||
if (path_type == .unc_absolute) {
|
||
// Now add in the UNC, the `C` should overwrite the first `\` of the
|
||
// FullPathName, ultimately resulting in `\??\UNC\<the rest of the path>`
|
||
std.debug.assert(path_space.data[path_buf_offset] == '\\');
|
||
std.debug.assert(path_space.data[path_buf_offset + 1] == '\\');
|
||
const unc = [_]u16{ 'U', 'N', 'C' };
|
||
path_space.data[nt_prefix.len..][0..unc.len].* = unc;
|
||
}
|
||
return path_space;
|
||
},
|
||
}
|
||
}
|
||
|
||
pub const NamespacePrefix = enum {
|
||
none,
|
||
/// `\\.\` (path separators can be `\` or `/`)
|
||
local_device,
|
||
/// `\\?\`
|
||
/// When converted to an NT path, everything past the prefix is left
|
||
/// untouched and `\\?\` is replaced by `\??\`.
|
||
verbatim,
|
||
/// `\\?\` without all path separators being `\`.
|
||
/// This seems to be recognized as a prefix, but the 'verbatim' aspect
|
||
/// is not respected (i.e. if `//?/C:/foo` is converted to an NT path,
|
||
/// it will become `\??\C:\foo` [it will be canonicalized and the //?/ won't
|
||
/// be treated as part of the final path])
|
||
fake_verbatim,
|
||
/// `\??\`
|
||
nt,
|
||
};
|
||
|
||
/// If `T` is `u16`, then `path` should be encoded as WTF-16LE.
|
||
pub fn getNamespacePrefix(comptime T: type, path: []const T) NamespacePrefix {
|
||
if (path.len < 4) return .none;
|
||
var all_backslash = switch (mem.littleToNative(T, path[0])) {
|
||
'\\' => true,
|
||
'/' => false,
|
||
else => return .none,
|
||
};
|
||
all_backslash = all_backslash and switch (mem.littleToNative(T, path[3])) {
|
||
'\\' => true,
|
||
'/' => false,
|
||
else => return .none,
|
||
};
|
||
switch (mem.littleToNative(T, path[1])) {
|
||
'?' => if (mem.littleToNative(T, path[2]) == '?' and all_backslash) return .nt else return .none,
|
||
'\\' => {},
|
||
'/' => all_backslash = false,
|
||
else => return .none,
|
||
}
|
||
return switch (mem.littleToNative(T, path[2])) {
|
||
'?' => if (all_backslash) .verbatim else .fake_verbatim,
|
||
'.' => .local_device,
|
||
else => .none,
|
||
};
|
||
}
|
||
|
||
test getNamespacePrefix {
|
||
try std.testing.expectEqual(NamespacePrefix.none, getNamespacePrefix(u8, ""));
|
||
try std.testing.expectEqual(NamespacePrefix.nt, getNamespacePrefix(u8, "\\??\\"));
|
||
try std.testing.expectEqual(NamespacePrefix.none, getNamespacePrefix(u8, "/??/"));
|
||
try std.testing.expectEqual(NamespacePrefix.none, getNamespacePrefix(u8, "/??\\"));
|
||
try std.testing.expectEqual(NamespacePrefix.none, getNamespacePrefix(u8, "\\?\\\\"));
|
||
try std.testing.expectEqual(NamespacePrefix.local_device, getNamespacePrefix(u8, "\\\\.\\"));
|
||
try std.testing.expectEqual(NamespacePrefix.local_device, getNamespacePrefix(u8, "\\\\./"));
|
||
try std.testing.expectEqual(NamespacePrefix.local_device, getNamespacePrefix(u8, "/\\./"));
|
||
try std.testing.expectEqual(NamespacePrefix.local_device, getNamespacePrefix(u8, "//./"));
|
||
try std.testing.expectEqual(NamespacePrefix.none, getNamespacePrefix(u8, "/.//"));
|
||
try std.testing.expectEqual(NamespacePrefix.verbatim, getNamespacePrefix(u8, "\\\\?\\"));
|
||
try std.testing.expectEqual(NamespacePrefix.fake_verbatim, getNamespacePrefix(u8, "\\/?\\"));
|
||
try std.testing.expectEqual(NamespacePrefix.fake_verbatim, getNamespacePrefix(u8, "\\/?/"));
|
||
try std.testing.expectEqual(NamespacePrefix.fake_verbatim, getNamespacePrefix(u8, "//?/"));
|
||
}
|
||
|
||
pub const UnprefixedPathType = enum {
|
||
unc_absolute,
|
||
drive_absolute,
|
||
drive_relative,
|
||
rooted,
|
||
relative,
|
||
root_local_device,
|
||
};
|
||
|
||
/// Get the path type of a path that is known to not have any namespace prefixes
|
||
/// (`\\?\`, `\\.\`, `\??\`).
|
||
/// If `T` is `u16`, then `path` should be encoded as WTF-16LE.
|
||
pub fn getUnprefixedPathType(comptime T: type, path: []const T) UnprefixedPathType {
|
||
if (path.len < 1) return .relative;
|
||
|
||
if (std.debug.runtime_safety) {
|
||
std.debug.assert(getNamespacePrefix(T, path) == .none);
|
||
}
|
||
|
||
const windows_path = std.fs.path.PathType.windows;
|
||
if (windows_path.isSep(T, mem.littleToNative(T, path[0]))) {
|
||
// \x
|
||
if (path.len < 2 or !windows_path.isSep(T, mem.littleToNative(T, path[1]))) return .rooted;
|
||
// exactly \\. or \\? with nothing trailing
|
||
if (path.len == 3 and (mem.littleToNative(T, path[2]) == '.' or mem.littleToNative(T, path[2]) == '?')) return .root_local_device;
|
||
// \\x
|
||
return .unc_absolute;
|
||
} else {
|
||
// x
|
||
if (path.len < 2 or mem.littleToNative(T, path[1]) != ':') return .relative;
|
||
// x:\
|
||
if (path.len > 2 and windows_path.isSep(T, mem.littleToNative(T, path[2]))) return .drive_absolute;
|
||
// x:
|
||
return .drive_relative;
|
||
}
|
||
}
|
||
|
||
test getUnprefixedPathType {
|
||
try std.testing.expectEqual(UnprefixedPathType.relative, getUnprefixedPathType(u8, ""));
|
||
try std.testing.expectEqual(UnprefixedPathType.relative, getUnprefixedPathType(u8, "x"));
|
||
try std.testing.expectEqual(UnprefixedPathType.relative, getUnprefixedPathType(u8, "x\\"));
|
||
try std.testing.expectEqual(UnprefixedPathType.root_local_device, getUnprefixedPathType(u8, "//."));
|
||
try std.testing.expectEqual(UnprefixedPathType.root_local_device, getUnprefixedPathType(u8, "/\\?"));
|
||
try std.testing.expectEqual(UnprefixedPathType.root_local_device, getUnprefixedPathType(u8, "\\\\?"));
|
||
try std.testing.expectEqual(UnprefixedPathType.unc_absolute, getUnprefixedPathType(u8, "\\\\x"));
|
||
try std.testing.expectEqual(UnprefixedPathType.unc_absolute, getUnprefixedPathType(u8, "//x"));
|
||
try std.testing.expectEqual(UnprefixedPathType.rooted, getUnprefixedPathType(u8, "\\x"));
|
||
try std.testing.expectEqual(UnprefixedPathType.rooted, getUnprefixedPathType(u8, "/"));
|
||
try std.testing.expectEqual(UnprefixedPathType.drive_relative, getUnprefixedPathType(u8, "x:"));
|
||
try std.testing.expectEqual(UnprefixedPathType.drive_relative, getUnprefixedPathType(u8, "x:abc"));
|
||
try std.testing.expectEqual(UnprefixedPathType.drive_relative, getUnprefixedPathType(u8, "x:a/b/c"));
|
||
try std.testing.expectEqual(UnprefixedPathType.drive_absolute, getUnprefixedPathType(u8, "x:\\"));
|
||
try std.testing.expectEqual(UnprefixedPathType.drive_absolute, getUnprefixedPathType(u8, "x:\\abc"));
|
||
try std.testing.expectEqual(UnprefixedPathType.drive_absolute, getUnprefixedPathType(u8, "x:/a/b/c"));
|
||
}
|
||
|
||
/// Similar to `RtlNtPathNameToDosPathName` but does not do any heap allocation.
|
||
/// The possible transformations are:
|
||
/// \??\C:\Some\Path -> C:\Some\Path
|
||
/// \??\UNC\server\share\foo -> \\server\share\foo
|
||
/// If the path does not have the NT namespace prefix, then `error.NotNtPath` is returned.
|
||
///
|
||
/// Functionality is based on the ReactOS test cases found here:
|
||
/// https://github.com/reactos/reactos/blob/master/modules/rostests/apitests/ntdll/RtlNtPathNameToDosPathName.c
|
||
///
|
||
/// `path` should be encoded as WTF-16LE.
|
||
pub fn ntToWin32Namespace(path: []const u16) !PathSpace {
|
||
if (path.len > PATH_MAX_WIDE) return error.NameTooLong;
|
||
|
||
var path_space: PathSpace = undefined;
|
||
const namespace_prefix = getNamespacePrefix(u16, path);
|
||
switch (namespace_prefix) {
|
||
.nt => {
|
||
var dest_index: usize = 0;
|
||
var after_prefix = path[4..]; // after the `\??\`
|
||
// The prefix \??\UNC\ means this is a UNC path, in which case the
|
||
// `\??\UNC\` should be replaced by `\\` (two backslashes)
|
||
// TODO: the "UNC" should technically be matched case-insensitively, but
|
||
// it's unlikely to matter since most/all paths passed into this
|
||
// function will have come from the OS meaning it should have
|
||
// the 'canonical' uppercase UNC.
|
||
const is_unc = after_prefix.len >= 4 and
|
||
std.mem.eql(u16, after_prefix[0..3], std.unicode.utf8ToUtf16LeStringLiteral("UNC")) and
|
||
std.fs.path.PathType.windows.isSep(u16, std.mem.littleToNative(u16, after_prefix[3]));
|
||
if (is_unc) {
|
||
path_space.data[0] = comptime std.mem.nativeToLittle(u16, '\\');
|
||
dest_index += 1;
|
||
// We want to include the last `\` of `\??\UNC\`
|
||
after_prefix = path[7..];
|
||
}
|
||
@memcpy(path_space.data[dest_index..][0..after_prefix.len], after_prefix);
|
||
path_space.len = dest_index + after_prefix.len;
|
||
path_space.data[path_space.len] = 0;
|
||
return path_space;
|
||
},
|
||
else => return error.NotNtPath,
|
||
}
|
||
}
|
||
|
||
test ntToWin32Namespace {
|
||
const L = std.unicode.utf8ToUtf16LeStringLiteral;
|
||
|
||
try testNtToWin32Namespace(L("UNC"), L("\\??\\UNC"));
|
||
try testNtToWin32Namespace(L("\\\\"), L("\\??\\UNC\\"));
|
||
try testNtToWin32Namespace(L("\\\\path1"), L("\\??\\UNC\\path1"));
|
||
try testNtToWin32Namespace(L("\\\\path1\\path2"), L("\\??\\UNC\\path1\\path2"));
|
||
|
||
try testNtToWin32Namespace(L(""), L("\\??\\"));
|
||
try testNtToWin32Namespace(L("C:"), L("\\??\\C:"));
|
||
try testNtToWin32Namespace(L("C:\\"), L("\\??\\C:\\"));
|
||
try testNtToWin32Namespace(L("C:\\test"), L("\\??\\C:\\test"));
|
||
try testNtToWin32Namespace(L("C:\\test\\"), L("\\??\\C:\\test\\"));
|
||
|
||
try std.testing.expectError(error.NotNtPath, ntToWin32Namespace(L("foo")));
|
||
try std.testing.expectError(error.NotNtPath, ntToWin32Namespace(L("C:\\test")));
|
||
try std.testing.expectError(error.NotNtPath, ntToWin32Namespace(L("\\\\.\\test")));
|
||
}
|
||
|
||
fn testNtToWin32Namespace(expected: []const u16, path: []const u16) !void {
|
||
const converted = try ntToWin32Namespace(path);
|
||
try std.testing.expectEqualSlices(u16, expected, converted.span());
|
||
}
|
||
|
||
fn getFullPathNameW(path: [*:0]const u16, out: []u16) !usize {
|
||
const result = kernel32.GetFullPathNameW(path, @as(u32, @intCast(out.len)), out.ptr, null);
|
||
if (result == 0) {
|
||
switch (GetLastError()) {
|
||
else => |err| return unexpectedError(err),
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
inline fn MAKELANGID(p: c_ushort, s: c_ushort) LANGID {
|
||
return (s << 10) | p;
|
||
}
|
||
|
||
/// Loads a Winsock extension function in runtime specified by a GUID.
|
||
pub fn loadWinsockExtensionFunction(comptime T: type, sock: ws2_32.SOCKET, guid: GUID) !T {
|
||
var function: T = undefined;
|
||
var num_bytes: DWORD = undefined;
|
||
|
||
const rc = ws2_32.WSAIoctl(
|
||
sock,
|
||
ws2_32.SIO_GET_EXTENSION_FUNCTION_POINTER,
|
||
&guid,
|
||
@sizeOf(GUID),
|
||
@as(?*anyopaque, @ptrFromInt(@intFromPtr(&function))),
|
||
@sizeOf(T),
|
||
&num_bytes,
|
||
null,
|
||
null,
|
||
);
|
||
|
||
if (rc == ws2_32.SOCKET_ERROR) {
|
||
return switch (ws2_32.WSAGetLastError()) {
|
||
.WSAEOPNOTSUPP => error.OperationNotSupported,
|
||
.WSAENOTSOCK => error.FileDescriptorNotASocket,
|
||
else => |err| unexpectedWSAError(err),
|
||
};
|
||
}
|
||
|
||
if (num_bytes != @sizeOf(T)) {
|
||
return error.ShortRead;
|
||
}
|
||
|
||
return function;
|
||
}
|
||
|
||
/// Call this when you made a windows DLL call or something that does SetLastError
|
||
/// and you get an unexpected error.
|
||
pub fn unexpectedError(err: Win32Error) UnexpectedError {
|
||
if (std.posix.unexpected_error_tracing) {
|
||
// 614 is the length of the longest windows error description
|
||
var buf_wstr: [614:0]WCHAR = undefined;
|
||
const len = kernel32.FormatMessageW(
|
||
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
|
||
null,
|
||
err,
|
||
MAKELANGID(LANG.NEUTRAL, SUBLANG.DEFAULT),
|
||
&buf_wstr,
|
||
buf_wstr.len,
|
||
null,
|
||
);
|
||
std.debug.print("error.Unexpected: GetLastError({}): {}\n", .{
|
||
@intFromEnum(err),
|
||
std.unicode.fmtUtf16Le(buf_wstr[0..len]),
|
||
});
|
||
std.debug.dumpCurrentStackTrace(@returnAddress());
|
||
}
|
||
return error.Unexpected;
|
||
}
|
||
|
||
pub fn unexpectedWSAError(err: ws2_32.WinsockError) UnexpectedError {
|
||
return unexpectedError(@as(Win32Error, @enumFromInt(@intFromEnum(err))));
|
||
}
|
||
|
||
/// Call this when you made a windows NtDll call
|
||
/// and you get an unexpected status.
|
||
pub fn unexpectedStatus(status: NTSTATUS) UnexpectedError {
|
||
if (std.posix.unexpected_error_tracing) {
|
||
std.debug.print("error.Unexpected NTSTATUS=0x{x}\n", .{@intFromEnum(status)});
|
||
std.debug.dumpCurrentStackTrace(@returnAddress());
|
||
}
|
||
return error.Unexpected;
|
||
}
|
||
|
||
pub const Win32Error = @import("windows/win32error.zig").Win32Error;
|
||
pub const NTSTATUS = @import("windows/ntstatus.zig").NTSTATUS;
|
||
pub const LANG = @import("windows/lang.zig");
|
||
pub const SUBLANG = @import("windows/sublang.zig");
|
||
|
||
/// The standard input device. Initially, this is the console input buffer, CONIN$.
|
||
pub const STD_INPUT_HANDLE = maxInt(DWORD) - 10 + 1;
|
||
|
||
/// The standard output device. Initially, this is the active console screen buffer, CONOUT$.
|
||
pub const STD_OUTPUT_HANDLE = maxInt(DWORD) - 11 + 1;
|
||
|
||
/// The standard error device. Initially, this is the active console screen buffer, CONOUT$.
|
||
pub const STD_ERROR_HANDLE = maxInt(DWORD) - 12 + 1;
|
||
|
||
pub const WINAPI: std.builtin.CallingConvention = .winapi;
|
||
|
||
pub const BOOL = c_int;
|
||
pub const BOOLEAN = BYTE;
|
||
pub const BYTE = u8;
|
||
pub const CHAR = u8;
|
||
pub const UCHAR = u8;
|
||
pub const FLOAT = f32;
|
||
pub const HANDLE = *anyopaque;
|
||
pub const HCRYPTPROV = ULONG_PTR;
|
||
pub const ATOM = u16;
|
||
pub const HBRUSH = *opaque {};
|
||
pub const HCURSOR = *opaque {};
|
||
pub const HICON = *opaque {};
|
||
pub const HINSTANCE = *opaque {};
|
||
pub const HMENU = *opaque {};
|
||
pub const HMODULE = *opaque {};
|
||
pub const HWND = *opaque {};
|
||
pub const HDC = *opaque {};
|
||
pub const HGLRC = *opaque {};
|
||
pub const FARPROC = *opaque {};
|
||
pub const PROC = *opaque {};
|
||
pub const INT = c_int;
|
||
pub const LPCSTR = [*:0]const CHAR;
|
||
pub const LPCVOID = *const anyopaque;
|
||
pub const LPSTR = [*:0]CHAR;
|
||
pub const LPVOID = *anyopaque;
|
||
pub const LPWSTR = [*:0]WCHAR;
|
||
pub const LPCWSTR = [*:0]const WCHAR;
|
||
pub const PVOID = *anyopaque;
|
||
pub const PWSTR = [*:0]WCHAR;
|
||
pub const PCWSTR = [*:0]const WCHAR;
|
||
/// Allocated by SysAllocString, freed by SysFreeString
|
||
pub const BSTR = [*:0]WCHAR;
|
||
pub const SIZE_T = usize;
|
||
pub const UINT = c_uint;
|
||
pub const ULONG_PTR = usize;
|
||
pub const LONG_PTR = isize;
|
||
pub const DWORD_PTR = ULONG_PTR;
|
||
pub const WCHAR = u16;
|
||
pub const WORD = u16;
|
||
pub const DWORD = u32;
|
||
pub const DWORD64 = u64;
|
||
pub const LARGE_INTEGER = i64;
|
||
pub const ULARGE_INTEGER = u64;
|
||
pub const USHORT = u16;
|
||
pub const SHORT = i16;
|
||
pub const ULONG = u32;
|
||
pub const LONG = i32;
|
||
pub const ULONG64 = u64;
|
||
pub const ULONGLONG = u64;
|
||
pub const LONGLONG = i64;
|
||
pub const HLOCAL = HANDLE;
|
||
pub const LANGID = c_ushort;
|
||
|
||
pub const WPARAM = usize;
|
||
pub const LPARAM = LONG_PTR;
|
||
pub const LRESULT = LONG_PTR;
|
||
|
||
pub const va_list = *opaque {};
|
||
|
||
pub const TCHAR = @compileError("Deprecated: choose between `CHAR` or `WCHAR` directly instead.");
|
||
pub const LPTSTR = @compileError("Deprecated: choose between `LPSTR` or `LPWSTR` directly instead.");
|
||
pub const LPCTSTR = @compileError("Deprecated: choose between `LPCSTR` or `LPCWSTR` directly instead.");
|
||
pub const PTSTR = @compileError("Deprecated: choose between `PSTR` or `PWSTR` directly instead.");
|
||
pub const PCTSTR = @compileError("Deprecated: choose between `PCSTR` or `PCWSTR` directly instead.");
|
||
|
||
pub const TRUE = 1;
|
||
pub const FALSE = 0;
|
||
|
||
pub const DEVICE_TYPE = ULONG;
|
||
pub const FILE_DEVICE_BEEP: DEVICE_TYPE = 0x0001;
|
||
pub const FILE_DEVICE_CD_ROM: DEVICE_TYPE = 0x0002;
|
||
pub const FILE_DEVICE_CD_ROM_FILE_SYSTEM: DEVICE_TYPE = 0x0003;
|
||
pub const FILE_DEVICE_CONTROLLER: DEVICE_TYPE = 0x0004;
|
||
pub const FILE_DEVICE_DATALINK: DEVICE_TYPE = 0x0005;
|
||
pub const FILE_DEVICE_DFS: DEVICE_TYPE = 0x0006;
|
||
pub const FILE_DEVICE_DISK: DEVICE_TYPE = 0x0007;
|
||
pub const FILE_DEVICE_DISK_FILE_SYSTEM: DEVICE_TYPE = 0x0008;
|
||
pub const FILE_DEVICE_FILE_SYSTEM: DEVICE_TYPE = 0x0009;
|
||
pub const FILE_DEVICE_INPORT_PORT: DEVICE_TYPE = 0x000a;
|
||
pub const FILE_DEVICE_KEYBOARD: DEVICE_TYPE = 0x000b;
|
||
pub const FILE_DEVICE_MAILSLOT: DEVICE_TYPE = 0x000c;
|
||
pub const FILE_DEVICE_MIDI_IN: DEVICE_TYPE = 0x000d;
|
||
pub const FILE_DEVICE_MIDI_OUT: DEVICE_TYPE = 0x000e;
|
||
pub const FILE_DEVICE_MOUSE: DEVICE_TYPE = 0x000f;
|
||
pub const FILE_DEVICE_MULTI_UNC_PROVIDER: DEVICE_TYPE = 0x0010;
|
||
pub const FILE_DEVICE_NAMED_PIPE: DEVICE_TYPE = 0x0011;
|
||
pub const FILE_DEVICE_NETWORK: DEVICE_TYPE = 0x0012;
|
||
pub const FILE_DEVICE_NETWORK_BROWSER: DEVICE_TYPE = 0x0013;
|
||
pub const FILE_DEVICE_NETWORK_FILE_SYSTEM: DEVICE_TYPE = 0x0014;
|
||
pub const FILE_DEVICE_NULL: DEVICE_TYPE = 0x0015;
|
||
pub const FILE_DEVICE_PARALLEL_PORT: DEVICE_TYPE = 0x0016;
|
||
pub const FILE_DEVICE_PHYSICAL_NETCARD: DEVICE_TYPE = 0x0017;
|
||
pub const FILE_DEVICE_PRINTER: DEVICE_TYPE = 0x0018;
|
||
pub const FILE_DEVICE_SCANNER: DEVICE_TYPE = 0x0019;
|
||
pub const FILE_DEVICE_SERIAL_MOUSE_PORT: DEVICE_TYPE = 0x001a;
|
||
pub const FILE_DEVICE_SERIAL_PORT: DEVICE_TYPE = 0x001b;
|
||
pub const FILE_DEVICE_SCREEN: DEVICE_TYPE = 0x001c;
|
||
pub const FILE_DEVICE_SOUND: DEVICE_TYPE = 0x001d;
|
||
pub const FILE_DEVICE_STREAMS: DEVICE_TYPE = 0x001e;
|
||
pub const FILE_DEVICE_TAPE: DEVICE_TYPE = 0x001f;
|
||
pub const FILE_DEVICE_TAPE_FILE_SYSTEM: DEVICE_TYPE = 0x0020;
|
||
pub const FILE_DEVICE_TRANSPORT: DEVICE_TYPE = 0x0021;
|
||
pub const FILE_DEVICE_UNKNOWN: DEVICE_TYPE = 0x0022;
|
||
pub const FILE_DEVICE_VIDEO: DEVICE_TYPE = 0x0023;
|
||
pub const FILE_DEVICE_VIRTUAL_DISK: DEVICE_TYPE = 0x0024;
|
||
pub const FILE_DEVICE_WAVE_IN: DEVICE_TYPE = 0x0025;
|
||
pub const FILE_DEVICE_WAVE_OUT: DEVICE_TYPE = 0x0026;
|
||
pub const FILE_DEVICE_8042_PORT: DEVICE_TYPE = 0x0027;
|
||
pub const FILE_DEVICE_NETWORK_REDIRECTOR: DEVICE_TYPE = 0x0028;
|
||
pub const FILE_DEVICE_BATTERY: DEVICE_TYPE = 0x0029;
|
||
pub const FILE_DEVICE_BUS_EXTENDER: DEVICE_TYPE = 0x002a;
|
||
pub const FILE_DEVICE_MODEM: DEVICE_TYPE = 0x002b;
|
||
pub const FILE_DEVICE_VDM: DEVICE_TYPE = 0x002c;
|
||
pub const FILE_DEVICE_MASS_STORAGE: DEVICE_TYPE = 0x002d;
|
||
pub const FILE_DEVICE_SMB: DEVICE_TYPE = 0x002e;
|
||
pub const FILE_DEVICE_KS: DEVICE_TYPE = 0x002f;
|
||
pub const FILE_DEVICE_CHANGER: DEVICE_TYPE = 0x0030;
|
||
pub const FILE_DEVICE_SMARTCARD: DEVICE_TYPE = 0x0031;
|
||
pub const FILE_DEVICE_ACPI: DEVICE_TYPE = 0x0032;
|
||
pub const FILE_DEVICE_DVD: DEVICE_TYPE = 0x0033;
|
||
pub const FILE_DEVICE_FULLSCREEN_VIDEO: DEVICE_TYPE = 0x0034;
|
||
pub const FILE_DEVICE_DFS_FILE_SYSTEM: DEVICE_TYPE = 0x0035;
|
||
pub const FILE_DEVICE_DFS_VOLUME: DEVICE_TYPE = 0x0036;
|
||
pub const FILE_DEVICE_SERENUM: DEVICE_TYPE = 0x0037;
|
||
pub const FILE_DEVICE_TERMSRV: DEVICE_TYPE = 0x0038;
|
||
pub const FILE_DEVICE_KSEC: DEVICE_TYPE = 0x0039;
|
||
pub const FILE_DEVICE_FIPS: DEVICE_TYPE = 0x003a;
|
||
pub const FILE_DEVICE_INFINIBAND: DEVICE_TYPE = 0x003b;
|
||
// TODO: missing values?
|
||
pub const FILE_DEVICE_VMBUS: DEVICE_TYPE = 0x003e;
|
||
pub const FILE_DEVICE_CRYPT_PROVIDER: DEVICE_TYPE = 0x003f;
|
||
pub const FILE_DEVICE_WPD: DEVICE_TYPE = 0x0040;
|
||
pub const FILE_DEVICE_BLUETOOTH: DEVICE_TYPE = 0x0041;
|
||
pub const FILE_DEVICE_MT_COMPOSITE: DEVICE_TYPE = 0x0042;
|
||
pub const FILE_DEVICE_MT_TRANSPORT: DEVICE_TYPE = 0x0043;
|
||
pub const FILE_DEVICE_BIOMETRIC: DEVICE_TYPE = 0x0044;
|
||
pub const FILE_DEVICE_PMI: DEVICE_TYPE = 0x0045;
|
||
pub const FILE_DEVICE_EHSTOR: DEVICE_TYPE = 0x0046;
|
||
pub const FILE_DEVICE_DEVAPI: DEVICE_TYPE = 0x0047;
|
||
pub const FILE_DEVICE_GPIO: DEVICE_TYPE = 0x0048;
|
||
pub const FILE_DEVICE_USBEX: DEVICE_TYPE = 0x0049;
|
||
pub const FILE_DEVICE_CONSOLE: DEVICE_TYPE = 0x0050;
|
||
pub const FILE_DEVICE_NFP: DEVICE_TYPE = 0x0051;
|
||
pub const FILE_DEVICE_SYSENV: DEVICE_TYPE = 0x0052;
|
||
pub const FILE_DEVICE_VIRTUAL_BLOCK: DEVICE_TYPE = 0x0053;
|
||
pub const FILE_DEVICE_POINT_OF_SERVICE: DEVICE_TYPE = 0x0054;
|
||
pub const FILE_DEVICE_STORAGE_REPLICATION: DEVICE_TYPE = 0x0055;
|
||
pub const FILE_DEVICE_TRUST_ENV: DEVICE_TYPE = 0x0056;
|
||
pub const FILE_DEVICE_UCM: DEVICE_TYPE = 0x0057;
|
||
pub const FILE_DEVICE_UCMTCPCI: DEVICE_TYPE = 0x0058;
|
||
pub const FILE_DEVICE_PERSISTENT_MEMORY: DEVICE_TYPE = 0x0059;
|
||
pub const FILE_DEVICE_NVDIMM: DEVICE_TYPE = 0x005a;
|
||
pub const FILE_DEVICE_HOLOGRAPHIC: DEVICE_TYPE = 0x005b;
|
||
pub const FILE_DEVICE_SDFXHCI: DEVICE_TYPE = 0x005c;
|
||
|
||
/// https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/buffer-descriptions-for-i-o-control-codes
|
||
pub const TransferType = enum(u2) {
|
||
METHOD_BUFFERED = 0,
|
||
METHOD_IN_DIRECT = 1,
|
||
METHOD_OUT_DIRECT = 2,
|
||
METHOD_NEITHER = 3,
|
||
};
|
||
|
||
pub const FILE_ANY_ACCESS = 0;
|
||
pub const FILE_READ_ACCESS = 1;
|
||
pub const FILE_WRITE_ACCESS = 2;
|
||
|
||
/// https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/defining-i-o-control-codes
|
||
pub fn CTL_CODE(deviceType: u16, function: u12, method: TransferType, access: u2) DWORD {
|
||
return (@as(DWORD, deviceType) << 16) |
|
||
(@as(DWORD, access) << 14) |
|
||
(@as(DWORD, function) << 2) |
|
||
@intFromEnum(method);
|
||
}
|
||
|
||
pub const INVALID_HANDLE_VALUE = @as(HANDLE, @ptrFromInt(maxInt(usize)));
|
||
|
||
pub const INVALID_FILE_ATTRIBUTES = @as(DWORD, maxInt(DWORD));
|
||
|
||
pub const FILE_ALL_INFORMATION = extern struct {
|
||
BasicInformation: FILE_BASIC_INFORMATION,
|
||
StandardInformation: FILE_STANDARD_INFORMATION,
|
||
InternalInformation: FILE_INTERNAL_INFORMATION,
|
||
EaInformation: FILE_EA_INFORMATION,
|
||
AccessInformation: FILE_ACCESS_INFORMATION,
|
||
PositionInformation: FILE_POSITION_INFORMATION,
|
||
ModeInformation: FILE_MODE_INFORMATION,
|
||
AlignmentInformation: FILE_ALIGNMENT_INFORMATION,
|
||
NameInformation: FILE_NAME_INFORMATION,
|
||
};
|
||
|
||
pub const FILE_BASIC_INFORMATION = extern struct {
|
||
CreationTime: LARGE_INTEGER,
|
||
LastAccessTime: LARGE_INTEGER,
|
||
LastWriteTime: LARGE_INTEGER,
|
||
ChangeTime: LARGE_INTEGER,
|
||
FileAttributes: ULONG,
|
||
};
|
||
|
||
pub const FILE_STANDARD_INFORMATION = extern struct {
|
||
AllocationSize: LARGE_INTEGER,
|
||
EndOfFile: LARGE_INTEGER,
|
||
NumberOfLinks: ULONG,
|
||
DeletePending: BOOLEAN,
|
||
Directory: BOOLEAN,
|
||
};
|
||
|
||
pub const FILE_INTERNAL_INFORMATION = extern struct {
|
||
IndexNumber: LARGE_INTEGER,
|
||
};
|
||
|
||
pub const FILE_EA_INFORMATION = extern struct {
|
||
EaSize: ULONG,
|
||
};
|
||
|
||
pub const FILE_ACCESS_INFORMATION = extern struct {
|
||
AccessFlags: ACCESS_MASK,
|
||
};
|
||
|
||
pub const FILE_POSITION_INFORMATION = extern struct {
|
||
CurrentByteOffset: LARGE_INTEGER,
|
||
};
|
||
|
||
pub const FILE_END_OF_FILE_INFORMATION = extern struct {
|
||
EndOfFile: LARGE_INTEGER,
|
||
};
|
||
|
||
pub const FILE_MODE_INFORMATION = extern struct {
|
||
Mode: ULONG,
|
||
};
|
||
|
||
pub const FILE_ALIGNMENT_INFORMATION = extern struct {
|
||
AlignmentRequirement: ULONG,
|
||
};
|
||
|
||
pub const FILE_NAME_INFORMATION = extern struct {
|
||
FileNameLength: ULONG,
|
||
FileName: [1]WCHAR,
|
||
};
|
||
|
||
pub const FILE_DISPOSITION_INFORMATION_EX = extern struct {
|
||
/// combination of FILE_DISPOSITION_* flags
|
||
Flags: ULONG,
|
||
};
|
||
|
||
const FILE_DISPOSITION_DO_NOT_DELETE: ULONG = 0x00000000;
|
||
const FILE_DISPOSITION_DELETE: ULONG = 0x00000001;
|
||
const FILE_DISPOSITION_POSIX_SEMANTICS: ULONG = 0x00000002;
|
||
const FILE_DISPOSITION_FORCE_IMAGE_SECTION_CHECK: ULONG = 0x00000004;
|
||
const FILE_DISPOSITION_ON_CLOSE: ULONG = 0x00000008;
|
||
const FILE_DISPOSITION_IGNORE_READONLY_ATTRIBUTE: ULONG = 0x00000010;
|
||
|
||
// FILE_RENAME_INFORMATION.Flags
|
||
pub const FILE_RENAME_REPLACE_IF_EXISTS = 0x00000001;
|
||
pub const FILE_RENAME_POSIX_SEMANTICS = 0x00000002;
|
||
pub const FILE_RENAME_SUPPRESS_PIN_STATE_INHERITANCE = 0x00000004;
|
||
pub const FILE_RENAME_SUPPRESS_STORAGE_RESERVE_INHERITANCE = 0x00000008;
|
||
pub const FILE_RENAME_NO_INCREASE_AVAILABLE_SPACE = 0x00000010;
|
||
pub const FILE_RENAME_NO_DECREASE_AVAILABLE_SPACE = 0x00000020;
|
||
pub const FILE_RENAME_PRESERVE_AVAILABLE_SPACE = 0x00000030;
|
||
pub const FILE_RENAME_IGNORE_READONLY_ATTRIBUTE = 0x00000040;
|
||
pub const FILE_RENAME_FORCE_RESIZE_TARGET_SR = 0x00000080;
|
||
pub const FILE_RENAME_FORCE_RESIZE_SOURCE_SR = 0x00000100;
|
||
pub const FILE_RENAME_FORCE_RESIZE_SR = 0x00000180;
|
||
|
||
pub const FILE_RENAME_INFORMATION = extern struct {
|
||
Flags: BOOLEAN,
|
||
RootDirectory: ?HANDLE,
|
||
FileNameLength: ULONG,
|
||
FileName: [1]WCHAR,
|
||
};
|
||
|
||
// FileRenameInformationEx (since .win10_rs1)
|
||
pub const FILE_RENAME_INFORMATION_EX = extern struct {
|
||
Flags: ULONG,
|
||
RootDirectory: ?HANDLE,
|
||
FileNameLength: ULONG,
|
||
FileName: [1]WCHAR,
|
||
};
|
||
|
||
pub const IO_STATUS_BLOCK = extern struct {
|
||
// "DUMMYUNIONNAME" expands to "u"
|
||
u: extern union {
|
||
Status: NTSTATUS,
|
||
Pointer: ?*anyopaque,
|
||
},
|
||
Information: ULONG_PTR,
|
||
};
|
||
|
||
pub const FILE_INFORMATION_CLASS = enum(c_int) {
|
||
FileDirectoryInformation = 1,
|
||
FileFullDirectoryInformation,
|
||
FileBothDirectoryInformation,
|
||
FileBasicInformation,
|
||
FileStandardInformation,
|
||
FileInternalInformation,
|
||
FileEaInformation,
|
||
FileAccessInformation,
|
||
FileNameInformation,
|
||
FileRenameInformation,
|
||
FileLinkInformation,
|
||
FileNamesInformation,
|
||
FileDispositionInformation,
|
||
FilePositionInformation,
|
||
FileFullEaInformation,
|
||
FileModeInformation,
|
||
FileAlignmentInformation,
|
||
FileAllInformation,
|
||
FileAllocationInformation,
|
||
FileEndOfFileInformation,
|
||
FileAlternateNameInformation,
|
||
FileStreamInformation,
|
||
FilePipeInformation,
|
||
FilePipeLocalInformation,
|
||
FilePipeRemoteInformation,
|
||
FileMailslotQueryInformation,
|
||
FileMailslotSetInformation,
|
||
FileCompressionInformation,
|
||
FileObjectIdInformation,
|
||
FileCompletionInformation,
|
||
FileMoveClusterInformation,
|
||
FileQuotaInformation,
|
||
FileReparsePointInformation,
|
||
FileNetworkOpenInformation,
|
||
FileAttributeTagInformation,
|
||
FileTrackingInformation,
|
||
FileIdBothDirectoryInformation,
|
||
FileIdFullDirectoryInformation,
|
||
FileValidDataLengthInformation,
|
||
FileShortNameInformation,
|
||
FileIoCompletionNotificationInformation,
|
||
FileIoStatusBlockRangeInformation,
|
||
FileIoPriorityHintInformation,
|
||
FileSfioReserveInformation,
|
||
FileSfioVolumeInformation,
|
||
FileHardLinkInformation,
|
||
FileProcessIdsUsingFileInformation,
|
||
FileNormalizedNameInformation,
|
||
FileNetworkPhysicalNameInformation,
|
||
FileIdGlobalTxDirectoryInformation,
|
||
FileIsRemoteDeviceInformation,
|
||
FileUnusedInformation,
|
||
FileNumaNodeInformation,
|
||
FileStandardLinkInformation,
|
||
FileRemoteProtocolInformation,
|
||
FileRenameInformationBypassAccessCheck,
|
||
FileLinkInformationBypassAccessCheck,
|
||
FileVolumeNameInformation,
|
||
FileIdInformation,
|
||
FileIdExtdDirectoryInformation,
|
||
FileReplaceCompletionInformation,
|
||
FileHardLinkFullIdInformation,
|
||
FileIdExtdBothDirectoryInformation,
|
||
FileDispositionInformationEx,
|
||
FileRenameInformationEx,
|
||
FileRenameInformationExBypassAccessCheck,
|
||
FileDesiredStorageClassInformation,
|
||
FileStatInformation,
|
||
FileMemoryPartitionInformation,
|
||
FileStatLxInformation,
|
||
FileCaseSensitiveInformation,
|
||
FileLinkInformationEx,
|
||
FileLinkInformationExBypassAccessCheck,
|
||
FileStorageReserveIdInformation,
|
||
FileCaseSensitiveInformationForceAccessCheck,
|
||
FileMaximumInformation,
|
||
};
|
||
|
||
pub const FILE_ATTRIBUTE_TAG_INFO = extern struct {
|
||
FileAttributes: DWORD,
|
||
ReparseTag: DWORD,
|
||
};
|
||
|
||
/// "If this bit is set, the file or directory represents another named entity in the system."
|
||
/// https://learn.microsoft.com/en-us/windows/win32/fileio/reparse-point-tags
|
||
pub const reparse_tag_name_surrogate_bit = 0x20000000;
|
||
|
||
pub const FILE_DISPOSITION_INFORMATION = extern struct {
|
||
DeleteFile: BOOLEAN,
|
||
};
|
||
|
||
pub const FILE_FS_DEVICE_INFORMATION = extern struct {
|
||
DeviceType: DEVICE_TYPE,
|
||
Characteristics: ULONG,
|
||
};
|
||
|
||
pub const FILE_FS_VOLUME_INFORMATION = extern struct {
|
||
VolumeCreationTime: LARGE_INTEGER,
|
||
VolumeSerialNumber: ULONG,
|
||
VolumeLabelLength: ULONG,
|
||
SupportsObjects: BOOLEAN,
|
||
// Flexible array member
|
||
VolumeLabel: [1]WCHAR,
|
||
};
|
||
|
||
pub const FS_INFORMATION_CLASS = enum(c_int) {
|
||
FileFsVolumeInformation = 1,
|
||
FileFsLabelInformation,
|
||
FileFsSizeInformation,
|
||
FileFsDeviceInformation,
|
||
FileFsAttributeInformation,
|
||
FileFsControlInformation,
|
||
FileFsFullSizeInformation,
|
||
FileFsObjectIdInformation,
|
||
FileFsDriverPathInformation,
|
||
FileFsVolumeFlagsInformation,
|
||
FileFsSectorSizeInformation,
|
||
FileFsDataCopyInformation,
|
||
FileFsMetadataSizeInformation,
|
||
FileFsFullSizeInformationEx,
|
||
FileFsMaximumInformation,
|
||
};
|
||
|
||
pub const OVERLAPPED = extern struct {
|
||
Internal: ULONG_PTR,
|
||
InternalHigh: ULONG_PTR,
|
||
DUMMYUNIONNAME: extern union {
|
||
DUMMYSTRUCTNAME: extern struct {
|
||
Offset: DWORD,
|
||
OffsetHigh: DWORD,
|
||
},
|
||
Pointer: ?PVOID,
|
||
},
|
||
hEvent: ?HANDLE,
|
||
};
|
||
|
||
pub const OVERLAPPED_ENTRY = extern struct {
|
||
lpCompletionKey: ULONG_PTR,
|
||
lpOverlapped: *OVERLAPPED,
|
||
Internal: ULONG_PTR,
|
||
dwNumberOfBytesTransferred: DWORD,
|
||
};
|
||
|
||
pub const MAX_PATH = 260;
|
||
|
||
pub const FILE_INFO_BY_HANDLE_CLASS = enum(u32) {
|
||
FileBasicInfo = 0,
|
||
FileStandardInfo = 1,
|
||
FileNameInfo = 2,
|
||
FileRenameInfo = 3,
|
||
FileDispositionInfo = 4,
|
||
FileAllocationInfo = 5,
|
||
FileEndOfFileInfo = 6,
|
||
FileStreamInfo = 7,
|
||
FileCompressionInfo = 8,
|
||
FileAttributeTagInfo = 9,
|
||
FileIdBothDirectoryInfo = 10,
|
||
FileIdBothDirectoryRestartInfo = 11,
|
||
FileIoPriorityHintInfo = 12,
|
||
FileRemoteProtocolInfo = 13,
|
||
FileFullDirectoryInfo = 14,
|
||
FileFullDirectoryRestartInfo = 15,
|
||
FileStorageInfo = 16,
|
||
FileAlignmentInfo = 17,
|
||
FileIdInfo = 18,
|
||
FileIdExtdDirectoryInfo = 19,
|
||
FileIdExtdDirectoryRestartInfo = 20,
|
||
};
|
||
|
||
pub const BY_HANDLE_FILE_INFORMATION = extern struct {
|
||
dwFileAttributes: DWORD,
|
||
ftCreationTime: FILETIME,
|
||
ftLastAccessTime: FILETIME,
|
||
ftLastWriteTime: FILETIME,
|
||
dwVolumeSerialNumber: DWORD,
|
||
nFileSizeHigh: DWORD,
|
||
nFileSizeLow: DWORD,
|
||
nNumberOfLinks: DWORD,
|
||
nFileIndexHigh: DWORD,
|
||
nFileIndexLow: DWORD,
|
||
};
|
||
|
||
pub const FILE_NAME_INFO = extern struct {
|
||
FileNameLength: DWORD,
|
||
FileName: [1]WCHAR,
|
||
};
|
||
|
||
/// Return the normalized drive name. This is the default.
|
||
pub const FILE_NAME_NORMALIZED = 0x0;
|
||
|
||
/// Return the opened file name (not normalized).
|
||
pub const FILE_NAME_OPENED = 0x8;
|
||
|
||
/// Return the path with the drive letter. This is the default.
|
||
pub const VOLUME_NAME_DOS = 0x0;
|
||
|
||
/// Return the path with a volume GUID path instead of the drive name.
|
||
pub const VOLUME_NAME_GUID = 0x1;
|
||
|
||
/// Return the path with no drive information.
|
||
pub const VOLUME_NAME_NONE = 0x4;
|
||
|
||
/// Return the path with the volume device path.
|
||
pub const VOLUME_NAME_NT = 0x2;
|
||
|
||
pub const SECURITY_ATTRIBUTES = extern struct {
|
||
nLength: DWORD,
|
||
lpSecurityDescriptor: ?*anyopaque,
|
||
bInheritHandle: BOOL,
|
||
};
|
||
|
||
pub const PIPE_ACCESS_INBOUND = 0x00000001;
|
||
pub const PIPE_ACCESS_OUTBOUND = 0x00000002;
|
||
pub const PIPE_ACCESS_DUPLEX = 0x00000003;
|
||
|
||
pub const PIPE_TYPE_BYTE = 0x00000000;
|
||
pub const PIPE_TYPE_MESSAGE = 0x00000004;
|
||
|
||
pub const PIPE_READMODE_BYTE = 0x00000000;
|
||
pub const PIPE_READMODE_MESSAGE = 0x00000002;
|
||
|
||
pub const PIPE_WAIT = 0x00000000;
|
||
pub const PIPE_NOWAIT = 0x00000001;
|
||
|
||
pub const GENERIC_READ = 0x80000000;
|
||
pub const GENERIC_WRITE = 0x40000000;
|
||
pub const GENERIC_EXECUTE = 0x20000000;
|
||
pub const GENERIC_ALL = 0x10000000;
|
||
|
||
pub const FILE_SHARE_DELETE = 0x00000004;
|
||
pub const FILE_SHARE_READ = 0x00000001;
|
||
pub const FILE_SHARE_WRITE = 0x00000002;
|
||
|
||
pub const DELETE = 0x00010000;
|
||
pub const READ_CONTROL = 0x00020000;
|
||
pub const WRITE_DAC = 0x00040000;
|
||
pub const WRITE_OWNER = 0x00080000;
|
||
pub const SYNCHRONIZE = 0x00100000;
|
||
pub const STANDARD_RIGHTS_READ = READ_CONTROL;
|
||
pub const STANDARD_RIGHTS_WRITE = READ_CONTROL;
|
||
pub const STANDARD_RIGHTS_EXECUTE = READ_CONTROL;
|
||
pub const STANDARD_RIGHTS_REQUIRED = DELETE | READ_CONTROL | WRITE_DAC | WRITE_OWNER;
|
||
pub const MAXIMUM_ALLOWED = 0x02000000;
|
||
|
||
// disposition for NtCreateFile
|
||
pub const FILE_SUPERSEDE = 0;
|
||
pub const FILE_OPEN = 1;
|
||
pub const FILE_CREATE = 2;
|
||
pub const FILE_OPEN_IF = 3;
|
||
pub const FILE_OVERWRITE = 4;
|
||
pub const FILE_OVERWRITE_IF = 5;
|
||
pub const FILE_MAXIMUM_DISPOSITION = 5;
|
||
|
||
// flags for NtCreateFile and NtOpenFile
|
||
pub const FILE_READ_DATA = 0x00000001;
|
||
pub const FILE_LIST_DIRECTORY = 0x00000001;
|
||
pub const FILE_WRITE_DATA = 0x00000002;
|
||
pub const FILE_ADD_FILE = 0x00000002;
|
||
pub const FILE_APPEND_DATA = 0x00000004;
|
||
pub const FILE_ADD_SUBDIRECTORY = 0x00000004;
|
||
pub const FILE_CREATE_PIPE_INSTANCE = 0x00000004;
|
||
pub const FILE_READ_EA = 0x00000008;
|
||
pub const FILE_WRITE_EA = 0x00000010;
|
||
pub const FILE_EXECUTE = 0x00000020;
|
||
pub const FILE_TRAVERSE = 0x00000020;
|
||
pub const FILE_DELETE_CHILD = 0x00000040;
|
||
pub const FILE_READ_ATTRIBUTES = 0x00000080;
|
||
pub const FILE_WRITE_ATTRIBUTES = 0x00000100;
|
||
|
||
pub const FILE_DIRECTORY_FILE = 0x00000001;
|
||
pub const FILE_WRITE_THROUGH = 0x00000002;
|
||
pub const FILE_SEQUENTIAL_ONLY = 0x00000004;
|
||
pub const FILE_NO_INTERMEDIATE_BUFFERING = 0x00000008;
|
||
pub const FILE_SYNCHRONOUS_IO_ALERT = 0x00000010;
|
||
pub const FILE_SYNCHRONOUS_IO_NONALERT = 0x00000020;
|
||
pub const FILE_NON_DIRECTORY_FILE = 0x00000040;
|
||
pub const FILE_CREATE_TREE_CONNECTION = 0x00000080;
|
||
pub const FILE_COMPLETE_IF_OPLOCKED = 0x00000100;
|
||
pub const FILE_NO_EA_KNOWLEDGE = 0x00000200;
|
||
pub const FILE_OPEN_FOR_RECOVERY = 0x00000400;
|
||
pub const FILE_RANDOM_ACCESS = 0x00000800;
|
||
pub const FILE_DELETE_ON_CLOSE = 0x00001000;
|
||
pub const FILE_OPEN_BY_FILE_ID = 0x00002000;
|
||
pub const FILE_OPEN_FOR_BACKUP_INTENT = 0x00004000;
|
||
pub const FILE_NO_COMPRESSION = 0x00008000;
|
||
pub const FILE_RESERVE_OPFILTER = 0x00100000;
|
||
pub const FILE_OPEN_REPARSE_POINT = 0x00200000;
|
||
pub const FILE_OPEN_OFFLINE_FILE = 0x00400000;
|
||
pub const FILE_OPEN_FOR_FREE_SPACE_QUERY = 0x00800000;
|
||
|
||
pub const CREATE_ALWAYS = 2;
|
||
pub const CREATE_NEW = 1;
|
||
pub const OPEN_ALWAYS = 4;
|
||
pub const OPEN_EXISTING = 3;
|
||
pub const TRUNCATE_EXISTING = 5;
|
||
|
||
pub const FILE_ATTRIBUTE_ARCHIVE = 0x20;
|
||
pub const FILE_ATTRIBUTE_COMPRESSED = 0x800;
|
||
pub const FILE_ATTRIBUTE_DEVICE = 0x40;
|
||
pub const FILE_ATTRIBUTE_DIRECTORY = 0x10;
|
||
pub const FILE_ATTRIBUTE_ENCRYPTED = 0x4000;
|
||
pub const FILE_ATTRIBUTE_HIDDEN = 0x2;
|
||
pub const FILE_ATTRIBUTE_INTEGRITY_STREAM = 0x8000;
|
||
pub const FILE_ATTRIBUTE_NORMAL = 0x80;
|
||
pub const FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 0x2000;
|
||
pub const FILE_ATTRIBUTE_NO_SCRUB_DATA = 0x20000;
|
||
pub const FILE_ATTRIBUTE_OFFLINE = 0x1000;
|
||
pub const FILE_ATTRIBUTE_READONLY = 0x1;
|
||
pub const FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS = 0x400000;
|
||
pub const FILE_ATTRIBUTE_RECALL_ON_OPEN = 0x40000;
|
||
pub const FILE_ATTRIBUTE_REPARSE_POINT = 0x400;
|
||
pub const FILE_ATTRIBUTE_SPARSE_FILE = 0x200;
|
||
pub const FILE_ATTRIBUTE_SYSTEM = 0x4;
|
||
pub const FILE_ATTRIBUTE_TEMPORARY = 0x100;
|
||
pub const FILE_ATTRIBUTE_VIRTUAL = 0x10000;
|
||
|
||
pub const FILE_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1ff;
|
||
pub const FILE_GENERIC_READ = STANDARD_RIGHTS_READ | FILE_READ_DATA | FILE_READ_ATTRIBUTES | FILE_READ_EA | SYNCHRONIZE;
|
||
pub const FILE_GENERIC_WRITE = STANDARD_RIGHTS_WRITE | FILE_WRITE_DATA | FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA | FILE_APPEND_DATA | SYNCHRONIZE;
|
||
pub const FILE_GENERIC_EXECUTE = STANDARD_RIGHTS_EXECUTE | FILE_READ_ATTRIBUTES | FILE_EXECUTE | SYNCHRONIZE;
|
||
|
||
// Flags for NtCreateNamedPipeFile
|
||
// NamedPipeType
|
||
pub const FILE_PIPE_BYTE_STREAM_TYPE = 0x0;
|
||
pub const FILE_PIPE_MESSAGE_TYPE = 0x1;
|
||
pub const FILE_PIPE_ACCEPT_REMOTE_CLIENTS = 0x0;
|
||
pub const FILE_PIPE_REJECT_REMOTE_CLIENTS = 0x2;
|
||
pub const FILE_PIPE_TYPE_VALID_MASK = 0x3;
|
||
// CompletionMode
|
||
pub const FILE_PIPE_QUEUE_OPERATION = 0x0;
|
||
pub const FILE_PIPE_COMPLETE_OPERATION = 0x1;
|
||
// ReadMode
|
||
pub const FILE_PIPE_BYTE_STREAM_MODE = 0x0;
|
||
pub const FILE_PIPE_MESSAGE_MODE = 0x1;
|
||
|
||
// flags for CreateEvent
|
||
pub const CREATE_EVENT_INITIAL_SET = 0x00000002;
|
||
pub const CREATE_EVENT_MANUAL_RESET = 0x00000001;
|
||
|
||
pub const EVENT_ALL_ACCESS = 0x1F0003;
|
||
pub const EVENT_MODIFY_STATE = 0x0002;
|
||
|
||
// MEMORY_BASIC_INFORMATION.Type flags for VirtualQuery
|
||
pub const MEM_IMAGE = 0x1000000;
|
||
pub const MEM_MAPPED = 0x40000;
|
||
pub const MEM_PRIVATE = 0x20000;
|
||
|
||
pub const PROCESS_INFORMATION = extern struct {
|
||
hProcess: HANDLE,
|
||
hThread: HANDLE,
|
||
dwProcessId: DWORD,
|
||
dwThreadId: DWORD,
|
||
};
|
||
|
||
pub const STARTUPINFOW = extern struct {
|
||
cb: DWORD,
|
||
lpReserved: ?LPWSTR,
|
||
lpDesktop: ?LPWSTR,
|
||
lpTitle: ?LPWSTR,
|
||
dwX: DWORD,
|
||
dwY: DWORD,
|
||
dwXSize: DWORD,
|
||
dwYSize: DWORD,
|
||
dwXCountChars: DWORD,
|
||
dwYCountChars: DWORD,
|
||
dwFillAttribute: DWORD,
|
||
dwFlags: DWORD,
|
||
wShowWindow: WORD,
|
||
cbReserved2: WORD,
|
||
lpReserved2: ?*BYTE,
|
||
hStdInput: ?HANDLE,
|
||
hStdOutput: ?HANDLE,
|
||
hStdError: ?HANDLE,
|
||
};
|
||
|
||
pub const STARTF_FORCEONFEEDBACK = 0x00000040;
|
||
pub const STARTF_FORCEOFFFEEDBACK = 0x00000080;
|
||
pub const STARTF_PREVENTPINNING = 0x00002000;
|
||
pub const STARTF_RUNFULLSCREEN = 0x00000020;
|
||
pub const STARTF_TITLEISAPPID = 0x00001000;
|
||
pub const STARTF_TITLEISLINKNAME = 0x00000800;
|
||
pub const STARTF_UNTRUSTEDSOURCE = 0x00008000;
|
||
pub const STARTF_USECOUNTCHARS = 0x00000008;
|
||
pub const STARTF_USEFILLATTRIBUTE = 0x00000010;
|
||
pub const STARTF_USEHOTKEY = 0x00000200;
|
||
pub const STARTF_USEPOSITION = 0x00000004;
|
||
pub const STARTF_USESHOWWINDOW = 0x00000001;
|
||
pub const STARTF_USESIZE = 0x00000002;
|
||
pub const STARTF_USESTDHANDLES = 0x00000100;
|
||
|
||
pub const INFINITE = 4294967295;
|
||
|
||
pub const MAXIMUM_WAIT_OBJECTS = 64;
|
||
|
||
pub const WAIT_ABANDONED = 0x00000080;
|
||
pub const WAIT_ABANDONED_0 = WAIT_ABANDONED + 0;
|
||
pub const WAIT_OBJECT_0 = 0x00000000;
|
||
pub const WAIT_TIMEOUT = 0x00000102;
|
||
pub const WAIT_FAILED = 0xFFFFFFFF;
|
||
|
||
pub const HANDLE_FLAG_INHERIT = 0x00000001;
|
||
pub const HANDLE_FLAG_PROTECT_FROM_CLOSE = 0x00000002;
|
||
|
||
pub const MOVEFILE_COPY_ALLOWED = 2;
|
||
pub const MOVEFILE_CREATE_HARDLINK = 16;
|
||
pub const MOVEFILE_DELAY_UNTIL_REBOOT = 4;
|
||
pub const MOVEFILE_FAIL_IF_NOT_TRACKABLE = 32;
|
||
pub const MOVEFILE_REPLACE_EXISTING = 1;
|
||
pub const MOVEFILE_WRITE_THROUGH = 8;
|
||
|
||
pub const FILE_BEGIN = 0;
|
||
pub const FILE_CURRENT = 1;
|
||
pub const FILE_END = 2;
|
||
|
||
pub const HEAP_CREATE_ENABLE_EXECUTE = 0x00040000;
|
||
pub const HEAP_REALLOC_IN_PLACE_ONLY = 0x00000010;
|
||
pub const HEAP_GENERATE_EXCEPTIONS = 0x00000004;
|
||
pub const HEAP_NO_SERIALIZE = 0x00000001;
|
||
|
||
// AllocationType values
|
||
pub const MEM_COMMIT = 0x1000;
|
||
pub const MEM_RESERVE = 0x2000;
|
||
pub const MEM_FREE = 0x10000;
|
||
pub const MEM_RESET = 0x80000;
|
||
pub const MEM_RESET_UNDO = 0x1000000;
|
||
pub const MEM_LARGE_PAGES = 0x20000000;
|
||
pub const MEM_PHYSICAL = 0x400000;
|
||
pub const MEM_TOP_DOWN = 0x100000;
|
||
pub const MEM_WRITE_WATCH = 0x200000;
|
||
|
||
// Protect values
|
||
pub const PAGE_EXECUTE = 0x10;
|
||
pub const PAGE_EXECUTE_READ = 0x20;
|
||
pub const PAGE_EXECUTE_READWRITE = 0x40;
|
||
pub const PAGE_EXECUTE_WRITECOPY = 0x80;
|
||
pub const PAGE_NOACCESS = 0x01;
|
||
pub const PAGE_READONLY = 0x02;
|
||
pub const PAGE_READWRITE = 0x04;
|
||
pub const PAGE_WRITECOPY = 0x08;
|
||
pub const PAGE_TARGETS_INVALID = 0x40000000;
|
||
pub const PAGE_TARGETS_NO_UPDATE = 0x40000000; // Same as PAGE_TARGETS_INVALID
|
||
pub const PAGE_GUARD = 0x100;
|
||
pub const PAGE_NOCACHE = 0x200;
|
||
pub const PAGE_WRITECOMBINE = 0x400;
|
||
|
||
// FreeType values
|
||
pub const MEM_COALESCE_PLACEHOLDERS = 0x1;
|
||
pub const MEM_RESERVE_PLACEHOLDERS = 0x2;
|
||
pub const MEM_DECOMMIT = 0x4000;
|
||
pub const MEM_RELEASE = 0x8000;
|
||
|
||
pub const PTHREAD_START_ROUTINE = *const fn (LPVOID) callconv(.C) DWORD;
|
||
pub const LPTHREAD_START_ROUTINE = PTHREAD_START_ROUTINE;
|
||
|
||
pub const WIN32_FIND_DATAW = extern struct {
|
||
dwFileAttributes: DWORD,
|
||
ftCreationTime: FILETIME,
|
||
ftLastAccessTime: FILETIME,
|
||
ftLastWriteTime: FILETIME,
|
||
nFileSizeHigh: DWORD,
|
||
nFileSizeLow: DWORD,
|
||
dwReserved0: DWORD,
|
||
dwReserved1: DWORD,
|
||
cFileName: [260]u16,
|
||
cAlternateFileName: [14]u16,
|
||
};
|
||
|
||
pub const FILETIME = extern struct {
|
||
dwLowDateTime: DWORD,
|
||
dwHighDateTime: DWORD,
|
||
};
|
||
|
||
pub const SYSTEM_INFO = extern struct {
|
||
anon1: extern union {
|
||
dwOemId: DWORD,
|
||
anon2: extern struct {
|
||
wProcessorArchitecture: WORD,
|
||
wReserved: WORD,
|
||
},
|
||
},
|
||
dwPageSize: DWORD,
|
||
lpMinimumApplicationAddress: LPVOID,
|
||
lpMaximumApplicationAddress: LPVOID,
|
||
dwActiveProcessorMask: DWORD_PTR,
|
||
dwNumberOfProcessors: DWORD,
|
||
dwProcessorType: DWORD,
|
||
dwAllocationGranularity: DWORD,
|
||
wProcessorLevel: WORD,
|
||
wProcessorRevision: WORD,
|
||
};
|
||
|
||
pub const HRESULT = c_long;
|
||
|
||
pub const KNOWNFOLDERID = GUID;
|
||
pub const GUID = extern struct {
|
||
Data1: u32,
|
||
Data2: u16,
|
||
Data3: u16,
|
||
Data4: [8]u8,
|
||
|
||
const hex_offsets = switch (builtin.target.cpu.arch.endian()) {
|
||
.big => [16]u6{
|
||
0, 2, 4, 6,
|
||
9, 11, 14, 16,
|
||
19, 21, 24, 26,
|
||
28, 30, 32, 34,
|
||
},
|
||
.little => [16]u6{
|
||
6, 4, 2, 0,
|
||
11, 9, 16, 14,
|
||
19, 21, 24, 26,
|
||
28, 30, 32, 34,
|
||
},
|
||
};
|
||
|
||
pub fn parse(s: []const u8) GUID {
|
||
assert(s[0] == '{');
|
||
assert(s[37] == '}');
|
||
return parseNoBraces(s[1 .. s.len - 1]) catch @panic("invalid GUID string");
|
||
}
|
||
|
||
pub fn parseNoBraces(s: []const u8) !GUID {
|
||
assert(s.len == 36);
|
||
assert(s[8] == '-');
|
||
assert(s[13] == '-');
|
||
assert(s[18] == '-');
|
||
assert(s[23] == '-');
|
||
var bytes: [16]u8 = undefined;
|
||
for (hex_offsets, 0..) |hex_offset, i| {
|
||
bytes[i] = (try std.fmt.charToDigit(s[hex_offset], 16)) << 4 |
|
||
try std.fmt.charToDigit(s[hex_offset + 1], 16);
|
||
}
|
||
return @as(GUID, @bitCast(bytes));
|
||
}
|
||
};
|
||
|
||
test GUID {
|
||
try std.testing.expectEqual(
|
||
GUID{
|
||
.Data1 = 0x01234567,
|
||
.Data2 = 0x89ab,
|
||
.Data3 = 0xef10,
|
||
.Data4 = "\x32\x54\x76\x98\xba\xdc\xfe\x91".*,
|
||
},
|
||
GUID.parse("{01234567-89AB-EF10-3254-7698badcfe91}"),
|
||
);
|
||
}
|
||
|
||
pub const FOLDERID_LocalAppData = GUID.parse("{F1B32785-6FBA-4FCF-9D55-7B8E7F157091}");
|
||
|
||
pub const KF_FLAG_DEFAULT = 0;
|
||
pub const KF_FLAG_NO_APPCONTAINER_REDIRECTION = 65536;
|
||
pub const KF_FLAG_CREATE = 32768;
|
||
pub const KF_FLAG_DONT_VERIFY = 16384;
|
||
pub const KF_FLAG_DONT_UNEXPAND = 8192;
|
||
pub const KF_FLAG_NO_ALIAS = 4096;
|
||
pub const KF_FLAG_INIT = 2048;
|
||
pub const KF_FLAG_DEFAULT_PATH = 1024;
|
||
pub const KF_FLAG_NOT_PARENT_RELATIVE = 512;
|
||
pub const KF_FLAG_SIMPLE_IDLIST = 256;
|
||
pub const KF_FLAG_ALIAS_ONLY = -2147483648;
|
||
|
||
pub const S_OK = 0;
|
||
pub const S_FALSE = 0x00000001;
|
||
pub const E_NOTIMPL = @as(c_long, @bitCast(@as(c_ulong, 0x80004001)));
|
||
pub const E_NOINTERFACE = @as(c_long, @bitCast(@as(c_ulong, 0x80004002)));
|
||
pub const E_POINTER = @as(c_long, @bitCast(@as(c_ulong, 0x80004003)));
|
||
pub const E_ABORT = @as(c_long, @bitCast(@as(c_ulong, 0x80004004)));
|
||
pub const E_FAIL = @as(c_long, @bitCast(@as(c_ulong, 0x80004005)));
|
||
pub const E_UNEXPECTED = @as(c_long, @bitCast(@as(c_ulong, 0x8000FFFF)));
|
||
pub const E_ACCESSDENIED = @as(c_long, @bitCast(@as(c_ulong, 0x80070005)));
|
||
pub const E_HANDLE = @as(c_long, @bitCast(@as(c_ulong, 0x80070006)));
|
||
pub const E_OUTOFMEMORY = @as(c_long, @bitCast(@as(c_ulong, 0x8007000E)));
|
||
pub const E_INVALIDARG = @as(c_long, @bitCast(@as(c_ulong, 0x80070057)));
|
||
|
||
pub fn HRESULT_CODE(hr: HRESULT) Win32Error {
|
||
return @enumFromInt(hr & 0xFFFF);
|
||
}
|
||
|
||
pub const FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;
|
||
pub const FILE_FLAG_DELETE_ON_CLOSE = 0x04000000;
|
||
pub const FILE_FLAG_NO_BUFFERING = 0x20000000;
|
||
pub const FILE_FLAG_OPEN_NO_RECALL = 0x00100000;
|
||
pub const FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000;
|
||
pub const FILE_FLAG_OVERLAPPED = 0x40000000;
|
||
pub const FILE_FLAG_POSIX_SEMANTICS = 0x0100000;
|
||
pub const FILE_FLAG_RANDOM_ACCESS = 0x10000000;
|
||
pub const FILE_FLAG_SESSION_AWARE = 0x00800000;
|
||
pub const FILE_FLAG_SEQUENTIAL_SCAN = 0x08000000;
|
||
pub const FILE_FLAG_WRITE_THROUGH = 0x80000000;
|
||
|
||
pub const RECT = extern struct {
|
||
left: LONG,
|
||
top: LONG,
|
||
right: LONG,
|
||
bottom: LONG,
|
||
};
|
||
|
||
pub const SMALL_RECT = extern struct {
|
||
Left: SHORT,
|
||
Top: SHORT,
|
||
Right: SHORT,
|
||
Bottom: SHORT,
|
||
};
|
||
|
||
pub const POINT = extern struct {
|
||
x: LONG,
|
||
y: LONG,
|
||
};
|
||
|
||
pub const COORD = extern struct {
|
||
X: SHORT,
|
||
Y: SHORT,
|
||
};
|
||
|
||
pub const CREATE_UNICODE_ENVIRONMENT = 1024;
|
||
|
||
pub const TLS_OUT_OF_INDEXES = 4294967295;
|
||
pub const IMAGE_TLS_DIRECTORY = extern struct {
|
||
StartAddressOfRawData: usize,
|
||
EndAddressOfRawData: usize,
|
||
AddressOfIndex: usize,
|
||
AddressOfCallBacks: usize,
|
||
SizeOfZeroFill: u32,
|
||
Characteristics: u32,
|
||
};
|
||
pub const IMAGE_TLS_DIRECTORY64 = IMAGE_TLS_DIRECTORY;
|
||
pub const IMAGE_TLS_DIRECTORY32 = IMAGE_TLS_DIRECTORY;
|
||
|
||
pub const PIMAGE_TLS_CALLBACK = ?*const fn (PVOID, DWORD, PVOID) callconv(.C) void;
|
||
|
||
pub const PROV_RSA_FULL = 1;
|
||
|
||
pub const REGSAM = ACCESS_MASK;
|
||
pub const ACCESS_MASK = DWORD;
|
||
pub const LSTATUS = LONG;
|
||
|
||
pub const SECTION_INHERIT = enum(c_int) {
|
||
ViewShare = 0,
|
||
ViewUnmap = 1,
|
||
};
|
||
|
||
pub const SECTION_QUERY = 0x0001;
|
||
pub const SECTION_MAP_WRITE = 0x0002;
|
||
pub const SECTION_MAP_READ = 0x0004;
|
||
pub const SECTION_MAP_EXECUTE = 0x0008;
|
||
pub const SECTION_EXTEND_SIZE = 0x0010;
|
||
pub const SECTION_ALL_ACCESS =
|
||
STANDARD_RIGHTS_REQUIRED |
|
||
SECTION_QUERY |
|
||
SECTION_MAP_WRITE |
|
||
SECTION_MAP_READ |
|
||
SECTION_MAP_EXECUTE |
|
||
SECTION_EXTEND_SIZE;
|
||
|
||
pub const SEC_64K_PAGES = 0x80000;
|
||
pub const SEC_FILE = 0x800000;
|
||
pub const SEC_IMAGE = 0x1000000;
|
||
pub const SEC_PROTECTED_IMAGE = 0x2000000;
|
||
pub const SEC_RESERVE = 0x4000000;
|
||
pub const SEC_COMMIT = 0x8000000;
|
||
pub const SEC_IMAGE_NO_EXECUTE = SEC_IMAGE | SEC_NOCACHE;
|
||
pub const SEC_NOCACHE = 0x10000000;
|
||
pub const SEC_WRITECOMBINE = 0x40000000;
|
||
pub const SEC_LARGE_PAGES = 0x80000000;
|
||
|
||
pub const HKEY = *opaque {};
|
||
|
||
pub const HKEY_CLASSES_ROOT: HKEY = @ptrFromInt(0x80000000);
|
||
pub const HKEY_CURRENT_USER: HKEY = @ptrFromInt(0x80000001);
|
||
pub const HKEY_LOCAL_MACHINE: HKEY = @ptrFromInt(0x80000002);
|
||
pub const HKEY_USERS: HKEY = @ptrFromInt(0x80000003);
|
||
pub const HKEY_PERFORMANCE_DATA: HKEY = @ptrFromInt(0x80000004);
|
||
pub const HKEY_PERFORMANCE_TEXT: HKEY = @ptrFromInt(0x80000050);
|
||
pub const HKEY_PERFORMANCE_NLSTEXT: HKEY = @ptrFromInt(0x80000060);
|
||
pub const HKEY_CURRENT_CONFIG: HKEY = @ptrFromInt(0x80000005);
|
||
pub const HKEY_DYN_DATA: HKEY = @ptrFromInt(0x80000006);
|
||
pub const HKEY_CURRENT_USER_LOCAL_SETTINGS: HKEY = @ptrFromInt(0x80000007);
|
||
|
||
/// Combines the STANDARD_RIGHTS_REQUIRED, KEY_QUERY_VALUE, KEY_SET_VALUE, KEY_CREATE_SUB_KEY,
|
||
/// KEY_ENUMERATE_SUB_KEYS, KEY_NOTIFY, and KEY_CREATE_LINK access rights.
|
||
pub const KEY_ALL_ACCESS = 0xF003F;
|
||
/// Reserved for system use.
|
||
pub const KEY_CREATE_LINK = 0x0020;
|
||
/// Required to create a subkey of a registry key.
|
||
pub const KEY_CREATE_SUB_KEY = 0x0004;
|
||
/// Required to enumerate the subkeys of a registry key.
|
||
pub const KEY_ENUMERATE_SUB_KEYS = 0x0008;
|
||
/// Equivalent to KEY_READ.
|
||
pub const KEY_EXECUTE = 0x20019;
|
||
/// Required to request change notifications for a registry key or for subkeys of a registry key.
|
||
pub const KEY_NOTIFY = 0x0010;
|
||
/// Required to query the values of a registry key.
|
||
pub const KEY_QUERY_VALUE = 0x0001;
|
||
/// Combines the STANDARD_RIGHTS_READ, KEY_QUERY_VALUE, KEY_ENUMERATE_SUB_KEYS, and KEY_NOTIFY values.
|
||
pub const KEY_READ = 0x20019;
|
||
/// Required to create, delete, or set a registry value.
|
||
pub const KEY_SET_VALUE = 0x0002;
|
||
/// Indicates that an application on 64-bit Windows should operate on the 32-bit registry view.
|
||
/// This flag is ignored by 32-bit Windows.
|
||
pub const KEY_WOW64_32KEY = 0x0200;
|
||
/// Indicates that an application on 64-bit Windows should operate on the 64-bit registry view.
|
||
/// This flag is ignored by 32-bit Windows.
|
||
pub const KEY_WOW64_64KEY = 0x0100;
|
||
/// Combines the STANDARD_RIGHTS_WRITE, KEY_SET_VALUE, and KEY_CREATE_SUB_KEY access rights.
|
||
pub const KEY_WRITE = 0x20006;
|
||
|
||
/// Open symbolic link.
|
||
pub const REG_OPTION_OPEN_LINK: DWORD = 0x8;
|
||
|
||
pub const RTL_QUERY_REGISTRY_TABLE = extern struct {
|
||
QueryRoutine: RTL_QUERY_REGISTRY_ROUTINE,
|
||
Flags: ULONG,
|
||
Name: ?PWSTR,
|
||
EntryContext: ?*anyopaque,
|
||
DefaultType: ULONG,
|
||
DefaultData: ?*anyopaque,
|
||
DefaultLength: ULONG,
|
||
};
|
||
|
||
pub const RTL_QUERY_REGISTRY_ROUTINE = ?*const fn (
|
||
PWSTR,
|
||
ULONG,
|
||
?*anyopaque,
|
||
ULONG,
|
||
?*anyopaque,
|
||
?*anyopaque,
|
||
) callconv(WINAPI) NTSTATUS;
|
||
|
||
/// Path is a full path
|
||
pub const RTL_REGISTRY_ABSOLUTE = 0;
|
||
/// \Registry\Machine\System\CurrentControlSet\Services
|
||
pub const RTL_REGISTRY_SERVICES = 1;
|
||
/// \Registry\Machine\System\CurrentControlSet\Control
|
||
pub const RTL_REGISTRY_CONTROL = 2;
|
||
/// \Registry\Machine\Software\Microsoft\Windows NT\CurrentVersion
|
||
pub const RTL_REGISTRY_WINDOWS_NT = 3;
|
||
/// \Registry\Machine\Hardware\DeviceMap
|
||
pub const RTL_REGISTRY_DEVICEMAP = 4;
|
||
/// \Registry\User\CurrentUser
|
||
pub const RTL_REGISTRY_USER = 5;
|
||
pub const RTL_REGISTRY_MAXIMUM = 6;
|
||
|
||
/// Low order bits are registry handle
|
||
pub const RTL_REGISTRY_HANDLE = 0x40000000;
|
||
/// Indicates the key node is optional
|
||
pub const RTL_REGISTRY_OPTIONAL = 0x80000000;
|
||
|
||
/// Name is a subkey and remainder of table or until next subkey are value
|
||
/// names for that subkey to look at.
|
||
pub const RTL_QUERY_REGISTRY_SUBKEY = 0x00000001;
|
||
|
||
/// Reset current key to original key for this and all following table entries.
|
||
pub const RTL_QUERY_REGISTRY_TOPKEY = 0x00000002;
|
||
|
||
/// Fail if no match found for this table entry.
|
||
pub const RTL_QUERY_REGISTRY_REQUIRED = 0x00000004;
|
||
|
||
/// Used to mark a table entry that has no value name, just wants a call out, not
|
||
/// an enumeration of all values.
|
||
pub const RTL_QUERY_REGISTRY_NOVALUE = 0x00000008;
|
||
|
||
/// Used to suppress the expansion of REG_MULTI_SZ into multiple callouts or
|
||
/// to prevent the expansion of environment variable values in REG_EXPAND_SZ.
|
||
pub const RTL_QUERY_REGISTRY_NOEXPAND = 0x00000010;
|
||
|
||
/// QueryRoutine field ignored. EntryContext field points to location to store value.
|
||
/// For null terminated strings, EntryContext points to UNICODE_STRING structure that
|
||
/// that describes maximum size of buffer. If .Buffer field is NULL then a buffer is
|
||
/// allocated.
|
||
pub const RTL_QUERY_REGISTRY_DIRECT = 0x00000020;
|
||
|
||
/// Used to delete value keys after they are queried.
|
||
pub const RTL_QUERY_REGISTRY_DELETE = 0x00000040;
|
||
|
||
/// Use this flag with the RTL_QUERY_REGISTRY_DIRECT flag to verify that the REG_XXX type
|
||
/// of the stored registry value matches the type expected by the caller.
|
||
/// If the types do not match, the call fails.
|
||
pub const RTL_QUERY_REGISTRY_TYPECHECK = 0x00000100;
|
||
|
||
pub const REG = struct {
|
||
/// No value type
|
||
pub const NONE: ULONG = 0;
|
||
/// Unicode nul terminated string
|
||
pub const SZ: ULONG = 1;
|
||
/// Unicode nul terminated string (with environment variable references)
|
||
pub const EXPAND_SZ: ULONG = 2;
|
||
/// Free form binary
|
||
pub const BINARY: ULONG = 3;
|
||
/// 32-bit number
|
||
pub const DWORD: ULONG = 4;
|
||
/// 32-bit number (same as REG_DWORD)
|
||
pub const DWORD_LITTLE_ENDIAN: ULONG = 4;
|
||
/// 32-bit number
|
||
pub const DWORD_BIG_ENDIAN: ULONG = 5;
|
||
/// Symbolic Link (unicode)
|
||
pub const LINK: ULONG = 6;
|
||
/// Multiple Unicode strings
|
||
pub const MULTI_SZ: ULONG = 7;
|
||
/// Resource list in the resource map
|
||
pub const RESOURCE_LIST: ULONG = 8;
|
||
/// Resource list in the hardware description
|
||
pub const FULL_RESOURCE_DESCRIPTOR: ULONG = 9;
|
||
pub const RESOURCE_REQUIREMENTS_LIST: ULONG = 10;
|
||
/// 64-bit number
|
||
pub const QWORD: ULONG = 11;
|
||
/// 64-bit number (same as REG_QWORD)
|
||
pub const QWORD_LITTLE_ENDIAN: ULONG = 11;
|
||
};
|
||
|
||
pub const FILE_NOTIFY_INFORMATION = extern struct {
|
||
NextEntryOffset: DWORD,
|
||
Action: DWORD,
|
||
FileNameLength: DWORD,
|
||
// Flexible array member
|
||
// FileName: [1]WCHAR,
|
||
};
|
||
|
||
pub const FILE_ACTION_ADDED = 0x00000001;
|
||
pub const FILE_ACTION_REMOVED = 0x00000002;
|
||
pub const FILE_ACTION_MODIFIED = 0x00000003;
|
||
pub const FILE_ACTION_RENAMED_OLD_NAME = 0x00000004;
|
||
pub const FILE_ACTION_RENAMED_NEW_NAME = 0x00000005;
|
||
|
||
pub const LPOVERLAPPED_COMPLETION_ROUTINE = ?*const fn (DWORD, DWORD, *OVERLAPPED) callconv(.C) void;
|
||
|
||
pub const FileNotifyChangeFilter = packed struct(DWORD) {
|
||
file_name: bool = false,
|
||
dir_name: bool = false,
|
||
attributes: bool = false,
|
||
size: bool = false,
|
||
last_write: bool = false,
|
||
last_access: bool = false,
|
||
creation: bool = false,
|
||
ea: bool = false,
|
||
security: bool = false,
|
||
stream_name: bool = false,
|
||
stream_size: bool = false,
|
||
stream_write: bool = false,
|
||
_pad: u20 = 0,
|
||
};
|
||
|
||
pub const CONSOLE_SCREEN_BUFFER_INFO = extern struct {
|
||
dwSize: COORD,
|
||
dwCursorPosition: COORD,
|
||
wAttributes: WORD,
|
||
srWindow: SMALL_RECT,
|
||
dwMaximumWindowSize: COORD,
|
||
};
|
||
|
||
pub const ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x4;
|
||
pub const DISABLE_NEWLINE_AUTO_RETURN = 0x8;
|
||
|
||
pub const FOREGROUND_BLUE = 1;
|
||
pub const FOREGROUND_GREEN = 2;
|
||
pub const FOREGROUND_RED = 4;
|
||
pub const FOREGROUND_INTENSITY = 8;
|
||
|
||
pub const LIST_ENTRY = extern struct {
|
||
Flink: *LIST_ENTRY,
|
||
Blink: *LIST_ENTRY,
|
||
};
|
||
|
||
pub const RTL_CRITICAL_SECTION_DEBUG = extern struct {
|
||
Type: WORD,
|
||
CreatorBackTraceIndex: WORD,
|
||
CriticalSection: *RTL_CRITICAL_SECTION,
|
||
ProcessLocksList: LIST_ENTRY,
|
||
EntryCount: DWORD,
|
||
ContentionCount: DWORD,
|
||
Flags: DWORD,
|
||
CreatorBackTraceIndexHigh: WORD,
|
||
SpareWORD: WORD,
|
||
};
|
||
|
||
pub const RTL_CRITICAL_SECTION = extern struct {
|
||
DebugInfo: *RTL_CRITICAL_SECTION_DEBUG,
|
||
LockCount: LONG,
|
||
RecursionCount: LONG,
|
||
OwningThread: HANDLE,
|
||
LockSemaphore: HANDLE,
|
||
SpinCount: ULONG_PTR,
|
||
};
|
||
|
||
pub const CRITICAL_SECTION = RTL_CRITICAL_SECTION;
|
||
pub const INIT_ONCE = RTL_RUN_ONCE;
|
||
pub const INIT_ONCE_STATIC_INIT = RTL_RUN_ONCE_INIT;
|
||
pub const INIT_ONCE_FN = *const fn (InitOnce: *INIT_ONCE, Parameter: ?*anyopaque, Context: ?*anyopaque) callconv(.C) BOOL;
|
||
|
||
pub const RTL_RUN_ONCE = extern struct {
|
||
Ptr: ?*anyopaque,
|
||
};
|
||
|
||
pub const RTL_RUN_ONCE_INIT = RTL_RUN_ONCE{ .Ptr = null };
|
||
|
||
pub const COINIT = struct {
|
||
pub const APARTMENTTHREADED = 2;
|
||
pub const MULTITHREADED = 0;
|
||
pub const DISABLE_OLE1DDE = 4;
|
||
pub const SPEED_OVER_MEMORY = 8;
|
||
};
|
||
|
||
pub const MEMORY_BASIC_INFORMATION = extern struct {
|
||
BaseAddress: PVOID,
|
||
AllocationBase: PVOID,
|
||
AllocationProtect: DWORD,
|
||
PartitionId: WORD,
|
||
RegionSize: SIZE_T,
|
||
State: DWORD,
|
||
Protect: DWORD,
|
||
Type: DWORD,
|
||
};
|
||
|
||
pub const PMEMORY_BASIC_INFORMATION = *MEMORY_BASIC_INFORMATION;
|
||
|
||
/// > The maximum path of 32,767 characters is approximate, because the "\\?\"
|
||
/// > prefix may be expanded to a longer string by the system at run time, and
|
||
/// > this expansion applies to the total length.
|
||
/// from https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#maximum-path-length-limitation
|
||
pub const PATH_MAX_WIDE = 32767;
|
||
|
||
/// > [Each file name component can be] up to the value returned in the
|
||
/// > lpMaximumComponentLength parameter of the GetVolumeInformation function
|
||
/// > (this value is commonly 255 characters)
|
||
/// from https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation
|
||
///
|
||
/// > The value that is stored in the variable that *lpMaximumComponentLength points to is
|
||
/// > used to indicate that a specified file system supports long names. For example, for
|
||
/// > a FAT file system that supports long names, the function stores the value 255, rather
|
||
/// > than the previous 8.3 indicator. Long names can also be supported on systems that use
|
||
/// > the NTFS file system.
|
||
/// from https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getvolumeinformationw
|
||
///
|
||
/// The assumption being made here is that while lpMaximumComponentLength may vary, it will never
|
||
/// be larger than 255.
|
||
///
|
||
/// TODO: More verification of this assumption.
|
||
pub const NAME_MAX = 255;
|
||
|
||
pub const FORMAT_MESSAGE_ALLOCATE_BUFFER = 0x00000100;
|
||
pub const FORMAT_MESSAGE_ARGUMENT_ARRAY = 0x00002000;
|
||
pub const FORMAT_MESSAGE_FROM_HMODULE = 0x00000800;
|
||
pub const FORMAT_MESSAGE_FROM_STRING = 0x00000400;
|
||
pub const FORMAT_MESSAGE_FROM_SYSTEM = 0x00001000;
|
||
pub const FORMAT_MESSAGE_IGNORE_INSERTS = 0x00000200;
|
||
pub const FORMAT_MESSAGE_MAX_WIDTH_MASK = 0x000000FF;
|
||
|
||
pub const EXCEPTION_DATATYPE_MISALIGNMENT = 0x80000002;
|
||
pub const EXCEPTION_ACCESS_VIOLATION = 0xc0000005;
|
||
pub const EXCEPTION_ILLEGAL_INSTRUCTION = 0xc000001d;
|
||
pub const EXCEPTION_STACK_OVERFLOW = 0xc00000fd;
|
||
pub const EXCEPTION_CONTINUE_SEARCH = 0;
|
||
|
||
pub const EXCEPTION_RECORD = extern struct {
|
||
ExceptionCode: u32,
|
||
ExceptionFlags: u32,
|
||
ExceptionRecord: *EXCEPTION_RECORD,
|
||
ExceptionAddress: *anyopaque,
|
||
NumberParameters: u32,
|
||
ExceptionInformation: [15]usize,
|
||
};
|
||
|
||
pub const FLOATING_SAVE_AREA = switch (native_arch) {
|
||
.x86 => extern struct {
|
||
ControlWord: DWORD,
|
||
StatusWord: DWORD,
|
||
TagWord: DWORD,
|
||
ErrorOffset: DWORD,
|
||
ErrorSelector: DWORD,
|
||
DataOffset: DWORD,
|
||
DataSelector: DWORD,
|
||
RegisterArea: [80]BYTE,
|
||
Cr0NpxState: DWORD,
|
||
},
|
||
else => @compileError("FLOATING_SAVE_AREA only defined on x86"),
|
||
};
|
||
|
||
pub const M128A = switch (native_arch) {
|
||
.x86_64 => extern struct {
|
||
Low: ULONGLONG,
|
||
High: LONGLONG,
|
||
},
|
||
else => @compileError("M128A only defined on x86_64"),
|
||
};
|
||
|
||
pub const XMM_SAVE_AREA32 = switch (native_arch) {
|
||
.x86_64 => extern struct {
|
||
ControlWord: WORD,
|
||
StatusWord: WORD,
|
||
TagWord: BYTE,
|
||
Reserved1: BYTE,
|
||
ErrorOpcode: WORD,
|
||
ErrorOffset: DWORD,
|
||
ErrorSelector: WORD,
|
||
Reserved2: WORD,
|
||
DataOffset: DWORD,
|
||
DataSelector: WORD,
|
||
Reserved3: WORD,
|
||
MxCsr: DWORD,
|
||
MxCsr_Mask: DWORD,
|
||
FloatRegisters: [8]M128A,
|
||
XmmRegisters: [16]M128A,
|
||
Reserved4: [96]BYTE,
|
||
},
|
||
else => @compileError("XMM_SAVE_AREA32 only defined on x86_64"),
|
||
};
|
||
|
||
pub const NEON128 = switch (native_arch) {
|
||
.thumb => extern struct {
|
||
Low: ULONGLONG,
|
||
High: LONGLONG,
|
||
},
|
||
.aarch64 => extern union {
|
||
DUMMYSTRUCTNAME: extern struct {
|
||
Low: ULONGLONG,
|
||
High: LONGLONG,
|
||
},
|
||
D: [2]f64,
|
||
S: [4]f32,
|
||
H: [8]WORD,
|
||
B: [16]BYTE,
|
||
},
|
||
else => @compileError("NEON128 only defined on aarch64"),
|
||
};
|
||
|
||
pub const CONTEXT = switch (native_arch) {
|
||
.x86 => extern struct {
|
||
ContextFlags: DWORD,
|
||
Dr0: DWORD,
|
||
Dr1: DWORD,
|
||
Dr2: DWORD,
|
||
Dr3: DWORD,
|
||
Dr6: DWORD,
|
||
Dr7: DWORD,
|
||
FloatSave: FLOATING_SAVE_AREA,
|
||
SegGs: DWORD,
|
||
SegFs: DWORD,
|
||
SegEs: DWORD,
|
||
SegDs: DWORD,
|
||
Edi: DWORD,
|
||
Esi: DWORD,
|
||
Ebx: DWORD,
|
||
Edx: DWORD,
|
||
Ecx: DWORD,
|
||
Eax: DWORD,
|
||
Ebp: DWORD,
|
||
Eip: DWORD,
|
||
SegCs: DWORD,
|
||
EFlags: DWORD,
|
||
Esp: DWORD,
|
||
SegSs: DWORD,
|
||
ExtendedRegisters: [512]BYTE,
|
||
|
||
pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize } {
|
||
return .{ .bp = ctx.Ebp, .ip = ctx.Eip };
|
||
}
|
||
},
|
||
.x86_64 => extern struct {
|
||
P1Home: DWORD64 align(16),
|
||
P2Home: DWORD64,
|
||
P3Home: DWORD64,
|
||
P4Home: DWORD64,
|
||
P5Home: DWORD64,
|
||
P6Home: DWORD64,
|
||
ContextFlags: DWORD,
|
||
MxCsr: DWORD,
|
||
SegCs: WORD,
|
||
SegDs: WORD,
|
||
SegEs: WORD,
|
||
SegFs: WORD,
|
||
SegGs: WORD,
|
||
SegSs: WORD,
|
||
EFlags: DWORD,
|
||
Dr0: DWORD64,
|
||
Dr1: DWORD64,
|
||
Dr2: DWORD64,
|
||
Dr3: DWORD64,
|
||
Dr6: DWORD64,
|
||
Dr7: DWORD64,
|
||
Rax: DWORD64,
|
||
Rcx: DWORD64,
|
||
Rdx: DWORD64,
|
||
Rbx: DWORD64,
|
||
Rsp: DWORD64,
|
||
Rbp: DWORD64,
|
||
Rsi: DWORD64,
|
||
Rdi: DWORD64,
|
||
R8: DWORD64,
|
||
R9: DWORD64,
|
||
R10: DWORD64,
|
||
R11: DWORD64,
|
||
R12: DWORD64,
|
||
R13: DWORD64,
|
||
R14: DWORD64,
|
||
R15: DWORD64,
|
||
Rip: DWORD64,
|
||
DUMMYUNIONNAME: extern union {
|
||
FltSave: XMM_SAVE_AREA32,
|
||
FloatSave: XMM_SAVE_AREA32,
|
||
DUMMYSTRUCTNAME: extern struct {
|
||
Header: [2]M128A,
|
||
Legacy: [8]M128A,
|
||
Xmm0: M128A,
|
||
Xmm1: M128A,
|
||
Xmm2: M128A,
|
||
Xmm3: M128A,
|
||
Xmm4: M128A,
|
||
Xmm5: M128A,
|
||
Xmm6: M128A,
|
||
Xmm7: M128A,
|
||
Xmm8: M128A,
|
||
Xmm9: M128A,
|
||
Xmm10: M128A,
|
||
Xmm11: M128A,
|
||
Xmm12: M128A,
|
||
Xmm13: M128A,
|
||
Xmm14: M128A,
|
||
Xmm15: M128A,
|
||
},
|
||
},
|
||
VectorRegister: [26]M128A,
|
||
VectorControl: DWORD64,
|
||
DebugControl: DWORD64,
|
||
LastBranchToRip: DWORD64,
|
||
LastBranchFromRip: DWORD64,
|
||
LastExceptionToRip: DWORD64,
|
||
LastExceptionFromRip: DWORD64,
|
||
|
||
pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize, sp: usize } {
|
||
return .{ .bp = ctx.Rbp, .ip = ctx.Rip, .sp = ctx.Rsp };
|
||
}
|
||
|
||
pub fn setIp(ctx: *CONTEXT, ip: usize) void {
|
||
ctx.Rip = ip;
|
||
}
|
||
|
||
pub fn setSp(ctx: *CONTEXT, sp: usize) void {
|
||
ctx.Rsp = sp;
|
||
}
|
||
},
|
||
.thumb => extern struct {
|
||
ContextFlags: ULONG,
|
||
R0: ULONG,
|
||
R1: ULONG,
|
||
R2: ULONG,
|
||
R3: ULONG,
|
||
R4: ULONG,
|
||
R5: ULONG,
|
||
R6: ULONG,
|
||
R7: ULONG,
|
||
R8: ULONG,
|
||
R9: ULONG,
|
||
R10: ULONG,
|
||
R11: ULONG,
|
||
R12: ULONG,
|
||
Sp: ULONG,
|
||
Lr: ULONG,
|
||
Pc: ULONG,
|
||
Cpsr: ULONG,
|
||
Fpcsr: ULONG,
|
||
Padding: ULONG,
|
||
DUMMYUNIONNAME: extern union {
|
||
Q: [16]NEON128,
|
||
D: [32]ULONGLONG,
|
||
S: [32]ULONG,
|
||
},
|
||
Bvr: [8]ULONG,
|
||
Bcr: [8]ULONG,
|
||
Wvr: [1]ULONG,
|
||
Wcr: [1]ULONG,
|
||
Padding2: [2]ULONG,
|
||
|
||
pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize, sp: usize } {
|
||
return .{
|
||
.bp = ctx.DUMMYUNIONNAME.S[11],
|
||
.ip = ctx.Pc,
|
||
.sp = ctx.Sp,
|
||
};
|
||
}
|
||
|
||
pub fn setIp(ctx: *CONTEXT, ip: usize) void {
|
||
ctx.Pc = ip;
|
||
}
|
||
|
||
pub fn setSp(ctx: *CONTEXT, sp: usize) void {
|
||
ctx.Sp = sp;
|
||
}
|
||
},
|
||
.aarch64 => extern struct {
|
||
ContextFlags: ULONG align(16),
|
||
Cpsr: ULONG,
|
||
DUMMYUNIONNAME: extern union {
|
||
DUMMYSTRUCTNAME: extern struct {
|
||
X0: DWORD64,
|
||
X1: DWORD64,
|
||
X2: DWORD64,
|
||
X3: DWORD64,
|
||
X4: DWORD64,
|
||
X5: DWORD64,
|
||
X6: DWORD64,
|
||
X7: DWORD64,
|
||
X8: DWORD64,
|
||
X9: DWORD64,
|
||
X10: DWORD64,
|
||
X11: DWORD64,
|
||
X12: DWORD64,
|
||
X13: DWORD64,
|
||
X14: DWORD64,
|
||
X15: DWORD64,
|
||
X16: DWORD64,
|
||
X17: DWORD64,
|
||
X18: DWORD64,
|
||
X19: DWORD64,
|
||
X20: DWORD64,
|
||
X21: DWORD64,
|
||
X22: DWORD64,
|
||
X23: DWORD64,
|
||
X24: DWORD64,
|
||
X25: DWORD64,
|
||
X26: DWORD64,
|
||
X27: DWORD64,
|
||
X28: DWORD64,
|
||
Fp: DWORD64,
|
||
Lr: DWORD64,
|
||
},
|
||
X: [31]DWORD64,
|
||
},
|
||
Sp: DWORD64,
|
||
Pc: DWORD64,
|
||
V: [32]NEON128,
|
||
Fpcr: DWORD,
|
||
Fpsr: DWORD,
|
||
Bcr: [8]DWORD,
|
||
Bvr: [8]DWORD64,
|
||
Wcr: [2]DWORD,
|
||
Wvr: [2]DWORD64,
|
||
|
||
pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize, sp: usize } {
|
||
return .{
|
||
.bp = ctx.DUMMYUNIONNAME.DUMMYSTRUCTNAME.Fp,
|
||
.ip = ctx.Pc,
|
||
.sp = ctx.Sp,
|
||
};
|
||
}
|
||
|
||
pub fn setIp(ctx: *CONTEXT, ip: usize) void {
|
||
ctx.Pc = ip;
|
||
}
|
||
|
||
pub fn setSp(ctx: *CONTEXT, sp: usize) void {
|
||
ctx.Sp = sp;
|
||
}
|
||
},
|
||
else => @compileError("CONTEXT is not defined for this architecture"),
|
||
};
|
||
|
||
pub const RUNTIME_FUNCTION = switch (native_arch) {
|
||
.x86_64 => extern struct {
|
||
BeginAddress: DWORD,
|
||
EndAddress: DWORD,
|
||
UnwindData: DWORD,
|
||
},
|
||
.thumb => extern struct {
|
||
BeginAddress: DWORD,
|
||
DUMMYUNIONNAME: extern union {
|
||
UnwindData: DWORD,
|
||
DUMMYSTRUCTNAME: packed struct {
|
||
Flag: u2,
|
||
FunctionLength: u11,
|
||
Ret: u2,
|
||
H: u1,
|
||
Reg: u3,
|
||
R: u1,
|
||
L: u1,
|
||
C: u1,
|
||
StackAdjust: u10,
|
||
},
|
||
},
|
||
},
|
||
.aarch64 => extern struct {
|
||
BeginAddress: DWORD,
|
||
DUMMYUNIONNAME: extern union {
|
||
UnwindData: DWORD,
|
||
DUMMYSTRUCTNAME: packed struct {
|
||
Flag: u2,
|
||
FunctionLength: u11,
|
||
RegF: u3,
|
||
RegI: u4,
|
||
H: u1,
|
||
CR: u2,
|
||
FrameSize: u9,
|
||
},
|
||
},
|
||
},
|
||
else => @compileError("RUNTIME_FUNCTION is not defined for this architecture"),
|
||
};
|
||
|
||
pub const KNONVOLATILE_CONTEXT_POINTERS = switch (native_arch) {
|
||
.x86_64 => extern struct {
|
||
FloatingContext: [16]?*M128A,
|
||
IntegerContext: [16]?*ULONG64,
|
||
},
|
||
.thumb => extern struct {
|
||
R4: ?*DWORD,
|
||
R5: ?*DWORD,
|
||
R6: ?*DWORD,
|
||
R7: ?*DWORD,
|
||
R8: ?*DWORD,
|
||
R9: ?*DWORD,
|
||
R10: ?*DWORD,
|
||
R11: ?*DWORD,
|
||
Lr: ?*DWORD,
|
||
D8: ?*ULONGLONG,
|
||
D9: ?*ULONGLONG,
|
||
D10: ?*ULONGLONG,
|
||
D11: ?*ULONGLONG,
|
||
D12: ?*ULONGLONG,
|
||
D13: ?*ULONGLONG,
|
||
D14: ?*ULONGLONG,
|
||
D15: ?*ULONGLONG,
|
||
},
|
||
.aarch64 => extern struct {
|
||
X19: ?*DWORD64,
|
||
X20: ?*DWORD64,
|
||
X21: ?*DWORD64,
|
||
X22: ?*DWORD64,
|
||
X23: ?*DWORD64,
|
||
X24: ?*DWORD64,
|
||
X25: ?*DWORD64,
|
||
X26: ?*DWORD64,
|
||
X27: ?*DWORD64,
|
||
X28: ?*DWORD64,
|
||
Fp: ?*DWORD64,
|
||
Lr: ?*DWORD64,
|
||
D8: ?*DWORD64,
|
||
D9: ?*DWORD64,
|
||
D10: ?*DWORD64,
|
||
D11: ?*DWORD64,
|
||
D12: ?*DWORD64,
|
||
D13: ?*DWORD64,
|
||
D14: ?*DWORD64,
|
||
D15: ?*DWORD64,
|
||
},
|
||
else => @compileError("KNONVOLATILE_CONTEXT_POINTERS is not defined for this architecture"),
|
||
};
|
||
|
||
pub const EXCEPTION_POINTERS = extern struct {
|
||
ExceptionRecord: *EXCEPTION_RECORD,
|
||
ContextRecord: *CONTEXT,
|
||
};
|
||
|
||
pub const VECTORED_EXCEPTION_HANDLER = *const fn (ExceptionInfo: *EXCEPTION_POINTERS) callconv(WINAPI) c_long;
|
||
|
||
pub const EXCEPTION_DISPOSITION = i32;
|
||
pub const EXCEPTION_ROUTINE = *const fn (
|
||
ExceptionRecord: ?*EXCEPTION_RECORD,
|
||
EstablisherFrame: PVOID,
|
||
ContextRecord: *(Self.CONTEXT),
|
||
DispatcherContext: PVOID,
|
||
) callconv(WINAPI) EXCEPTION_DISPOSITION;
|
||
|
||
pub const UNWIND_HISTORY_TABLE_SIZE = 12;
|
||
pub const UNWIND_HISTORY_TABLE_ENTRY = extern struct {
|
||
ImageBase: ULONG64,
|
||
FunctionEntry: *Self.RUNTIME_FUNCTION,
|
||
};
|
||
|
||
pub const UNWIND_HISTORY_TABLE = extern struct {
|
||
Count: ULONG,
|
||
LocalHint: BYTE,
|
||
GlobalHint: BYTE,
|
||
Search: BYTE,
|
||
Once: BYTE,
|
||
LowAddress: ULONG64,
|
||
HighAddress: ULONG64,
|
||
Entry: [UNWIND_HISTORY_TABLE_SIZE]UNWIND_HISTORY_TABLE_ENTRY,
|
||
};
|
||
|
||
pub const UNW_FLAG_NHANDLER = 0x0;
|
||
pub const UNW_FLAG_EHANDLER = 0x1;
|
||
pub const UNW_FLAG_UHANDLER = 0x2;
|
||
pub const UNW_FLAG_CHAININFO = 0x4;
|
||
|
||
pub const OBJECT_ATTRIBUTES = extern struct {
|
||
Length: ULONG,
|
||
RootDirectory: ?HANDLE,
|
||
ObjectName: *UNICODE_STRING,
|
||
Attributes: ULONG,
|
||
SecurityDescriptor: ?*anyopaque,
|
||
SecurityQualityOfService: ?*anyopaque,
|
||
};
|
||
|
||
pub const OBJ_INHERIT = 0x00000002;
|
||
pub const OBJ_PERMANENT = 0x00000010;
|
||
pub const OBJ_EXCLUSIVE = 0x00000020;
|
||
pub const OBJ_CASE_INSENSITIVE = 0x00000040;
|
||
pub const OBJ_OPENIF = 0x00000080;
|
||
pub const OBJ_OPENLINK = 0x00000100;
|
||
pub const OBJ_KERNEL_HANDLE = 0x00000200;
|
||
pub const OBJ_VALID_ATTRIBUTES = 0x000003F2;
|
||
|
||
pub const UNICODE_STRING = extern struct {
|
||
Length: c_ushort,
|
||
MaximumLength: c_ushort,
|
||
Buffer: ?[*]WCHAR,
|
||
};
|
||
|
||
pub const ACTIVATION_CONTEXT_DATA = opaque {};
|
||
pub const ASSEMBLY_STORAGE_MAP = opaque {};
|
||
pub const FLS_CALLBACK_INFO = opaque {};
|
||
pub const RTL_BITMAP = opaque {};
|
||
pub const KAFFINITY = usize;
|
||
pub const KPRIORITY = i32;
|
||
|
||
pub const CLIENT_ID = extern struct {
|
||
UniqueProcess: HANDLE,
|
||
UniqueThread: HANDLE,
|
||
};
|
||
|
||
pub const THREAD_BASIC_INFORMATION = extern struct {
|
||
ExitStatus: NTSTATUS,
|
||
TebBaseAddress: PVOID,
|
||
ClientId: CLIENT_ID,
|
||
AffinityMask: KAFFINITY,
|
||
Priority: KPRIORITY,
|
||
BasePriority: KPRIORITY,
|
||
};
|
||
|
||
pub const TEB = extern struct {
|
||
NtTib: NT_TIB,
|
||
EnvironmentPointer: PVOID,
|
||
ClientId: CLIENT_ID,
|
||
ActiveRpcHandle: PVOID,
|
||
ThreadLocalStoragePointer: PVOID,
|
||
ProcessEnvironmentBlock: *PEB,
|
||
LastErrorValue: ULONG,
|
||
Reserved2: [399 * @sizeOf(PVOID) - @sizeOf(ULONG)]u8,
|
||
Reserved3: [1952]u8,
|
||
TlsSlots: [64]PVOID,
|
||
Reserved4: [8]u8,
|
||
Reserved5: [26]PVOID,
|
||
ReservedForOle: PVOID,
|
||
Reserved6: [4]PVOID,
|
||
TlsExpansionSlots: PVOID,
|
||
};
|
||
|
||
comptime {
|
||
// Offsets taken from WinDbg info and Geoff Chappell[1] (RIP)
|
||
// [1]: https://www.geoffchappell.com/studies/windows/km/ntoskrnl/inc/api/pebteb/teb/index.htm
|
||
assert(@offsetOf(TEB, "NtTib") == 0x00);
|
||
if (@sizeOf(usize) == 4) {
|
||
assert(@offsetOf(TEB, "EnvironmentPointer") == 0x1C);
|
||
assert(@offsetOf(TEB, "ClientId") == 0x20);
|
||
assert(@offsetOf(TEB, "ActiveRpcHandle") == 0x28);
|
||
assert(@offsetOf(TEB, "ThreadLocalStoragePointer") == 0x2C);
|
||
assert(@offsetOf(TEB, "ProcessEnvironmentBlock") == 0x30);
|
||
assert(@offsetOf(TEB, "LastErrorValue") == 0x34);
|
||
assert(@offsetOf(TEB, "TlsSlots") == 0xe10);
|
||
} else if (@sizeOf(usize) == 8) {
|
||
assert(@offsetOf(TEB, "EnvironmentPointer") == 0x38);
|
||
assert(@offsetOf(TEB, "ClientId") == 0x40);
|
||
assert(@offsetOf(TEB, "ActiveRpcHandle") == 0x50);
|
||
assert(@offsetOf(TEB, "ThreadLocalStoragePointer") == 0x58);
|
||
assert(@offsetOf(TEB, "ProcessEnvironmentBlock") == 0x60);
|
||
assert(@offsetOf(TEB, "LastErrorValue") == 0x68);
|
||
assert(@offsetOf(TEB, "TlsSlots") == 0x1480);
|
||
}
|
||
}
|
||
|
||
pub const EXCEPTION_REGISTRATION_RECORD = extern struct {
|
||
Next: ?*EXCEPTION_REGISTRATION_RECORD,
|
||
Handler: ?*EXCEPTION_DISPOSITION,
|
||
};
|
||
|
||
pub const NT_TIB = extern struct {
|
||
ExceptionList: ?*EXCEPTION_REGISTRATION_RECORD,
|
||
StackBase: PVOID,
|
||
StackLimit: PVOID,
|
||
SubSystemTib: PVOID,
|
||
DUMMYUNIONNAME: extern union { FiberData: PVOID, Version: DWORD },
|
||
ArbitraryUserPointer: PVOID,
|
||
Self: ?*@This(),
|
||
};
|
||
|
||
/// Process Environment Block
|
||
/// Microsoft documentation of this is incomplete, the fields here are taken from various resources including:
|
||
/// - https://github.com/wine-mirror/wine/blob/1aff1e6a370ee8c0213a0fd4b220d121da8527aa/include/winternl.h#L269
|
||
/// - https://www.geoffchappell.com/studies/windows/win32/ntdll/structs/peb/index.htm
|
||
pub const PEB = extern struct {
|
||
// Versions: All
|
||
InheritedAddressSpace: BOOLEAN,
|
||
|
||
// Versions: 3.51+
|
||
ReadImageFileExecOptions: BOOLEAN,
|
||
BeingDebugged: BOOLEAN,
|
||
|
||
// Versions: 5.2+ (previously was padding)
|
||
BitField: UCHAR,
|
||
|
||
// Versions: all
|
||
Mutant: HANDLE,
|
||
ImageBaseAddress: HMODULE,
|
||
Ldr: *PEB_LDR_DATA,
|
||
ProcessParameters: *RTL_USER_PROCESS_PARAMETERS,
|
||
SubSystemData: PVOID,
|
||
ProcessHeap: HANDLE,
|
||
|
||
// Versions: 5.1+
|
||
FastPebLock: *RTL_CRITICAL_SECTION,
|
||
|
||
// Versions: 5.2+
|
||
AtlThunkSListPtr: PVOID,
|
||
IFEOKey: PVOID,
|
||
|
||
// Versions: 6.0+
|
||
|
||
/// https://www.geoffchappell.com/studies/windows/win32/ntdll/structs/peb/crossprocessflags.htm
|
||
CrossProcessFlags: ULONG,
|
||
|
||
// Versions: 6.0+
|
||
union1: extern union {
|
||
KernelCallbackTable: PVOID,
|
||
UserSharedInfoPtr: PVOID,
|
||
},
|
||
|
||
// Versions: 5.1+
|
||
SystemReserved: ULONG,
|
||
|
||
// Versions: 5.1, (not 5.2, not 6.0), 6.1+
|
||
AtlThunkSListPtr32: ULONG,
|
||
|
||
// Versions: 6.1+
|
||
ApiSetMap: PVOID,
|
||
|
||
// Versions: all
|
||
TlsExpansionCounter: ULONG,
|
||
// note: there is padding here on 64 bit
|
||
TlsBitmap: *RTL_BITMAP,
|
||
TlsBitmapBits: [2]ULONG,
|
||
ReadOnlySharedMemoryBase: PVOID,
|
||
|
||
// Versions: 1703+
|
||
SharedData: PVOID,
|
||
|
||
// Versions: all
|
||
ReadOnlyStaticServerData: *PVOID,
|
||
AnsiCodePageData: PVOID,
|
||
OemCodePageData: PVOID,
|
||
UnicodeCaseTableData: PVOID,
|
||
|
||
// Versions: 3.51+
|
||
NumberOfProcessors: ULONG,
|
||
NtGlobalFlag: ULONG,
|
||
|
||
// Versions: all
|
||
CriticalSectionTimeout: LARGE_INTEGER,
|
||
|
||
// End of Original PEB size
|
||
|
||
// Fields appended in 3.51:
|
||
HeapSegmentReserve: ULONG_PTR,
|
||
HeapSegmentCommit: ULONG_PTR,
|
||
HeapDeCommitTotalFreeThreshold: ULONG_PTR,
|
||
HeapDeCommitFreeBlockThreshold: ULONG_PTR,
|
||
NumberOfHeaps: ULONG,
|
||
MaximumNumberOfHeaps: ULONG,
|
||
ProcessHeaps: *PVOID,
|
||
|
||
// Fields appended in 4.0:
|
||
GdiSharedHandleTable: PVOID,
|
||
ProcessStarterHelper: PVOID,
|
||
GdiDCAttributeList: ULONG,
|
||
// note: there is padding here on 64 bit
|
||
LoaderLock: *RTL_CRITICAL_SECTION,
|
||
OSMajorVersion: ULONG,
|
||
OSMinorVersion: ULONG,
|
||
OSBuildNumber: USHORT,
|
||
OSCSDVersion: USHORT,
|
||
OSPlatformId: ULONG,
|
||
ImageSubSystem: ULONG,
|
||
ImageSubSystemMajorVersion: ULONG,
|
||
ImageSubSystemMinorVersion: ULONG,
|
||
// note: there is padding here on 64 bit
|
||
ActiveProcessAffinityMask: KAFFINITY,
|
||
GdiHandleBuffer: [
|
||
switch (@sizeOf(usize)) {
|
||
4 => 0x22,
|
||
8 => 0x3C,
|
||
else => unreachable,
|
||
}
|
||
]ULONG,
|
||
|
||
// Fields appended in 5.0 (Windows 2000):
|
||
PostProcessInitRoutine: PVOID,
|
||
TlsExpansionBitmap: *RTL_BITMAP,
|
||
TlsExpansionBitmapBits: [32]ULONG,
|
||
SessionId: ULONG,
|
||
// note: there is padding here on 64 bit
|
||
// Versions: 5.1+
|
||
AppCompatFlags: ULARGE_INTEGER,
|
||
AppCompatFlagsUser: ULARGE_INTEGER,
|
||
ShimData: PVOID,
|
||
// Versions: 5.0+
|
||
AppCompatInfo: PVOID,
|
||
CSDVersion: UNICODE_STRING,
|
||
|
||
// Fields appended in 5.1 (Windows XP):
|
||
ActivationContextData: *const ACTIVATION_CONTEXT_DATA,
|
||
ProcessAssemblyStorageMap: *ASSEMBLY_STORAGE_MAP,
|
||
SystemDefaultActivationData: *const ACTIVATION_CONTEXT_DATA,
|
||
SystemAssemblyStorageMap: *ASSEMBLY_STORAGE_MAP,
|
||
MinimumStackCommit: ULONG_PTR,
|
||
|
||
// Fields appended in 5.2 (Windows Server 2003):
|
||
FlsCallback: *FLS_CALLBACK_INFO,
|
||
FlsListHead: LIST_ENTRY,
|
||
FlsBitmap: *RTL_BITMAP,
|
||
FlsBitmapBits: [4]ULONG,
|
||
FlsHighIndex: ULONG,
|
||
|
||
// Fields appended in 6.0 (Windows Vista):
|
||
WerRegistrationData: PVOID,
|
||
WerShipAssertPtr: PVOID,
|
||
|
||
// Fields appended in 6.1 (Windows 7):
|
||
pUnused: PVOID, // previously pContextData
|
||
pImageHeaderHash: PVOID,
|
||
|
||
/// TODO: https://www.geoffchappell.com/studies/windows/win32/ntdll/structs/peb/tracingflags.htm
|
||
TracingFlags: ULONG,
|
||
|
||
// Fields appended in 6.2 (Windows 8):
|
||
CsrServerReadOnlySharedMemoryBase: ULONGLONG,
|
||
|
||
// Fields appended in 1511:
|
||
TppWorkerpListLock: ULONG,
|
||
TppWorkerpList: LIST_ENTRY,
|
||
WaitOnAddressHashTable: [0x80]PVOID,
|
||
|
||
// Fields appended in 1709:
|
||
TelemetryCoverageHeader: PVOID,
|
||
CloudFileFlags: ULONG,
|
||
};
|
||
|
||
/// The `PEB_LDR_DATA` structure is the main record of what modules are loaded in a process.
|
||
/// It is essentially the head of three double-linked lists of `LDR_DATA_TABLE_ENTRY` structures which each represent one loaded module.
|
||
///
|
||
/// Microsoft documentation of this is incomplete, the fields here are taken from various resources including:
|
||
/// - https://www.geoffchappell.com/studies/windows/win32/ntdll/structs/peb_ldr_data.htm
|
||
pub const PEB_LDR_DATA = extern struct {
|
||
// Versions: 3.51 and higher
|
||
/// The size in bytes of the structure
|
||
Length: ULONG,
|
||
|
||
/// TRUE if the structure is prepared.
|
||
Initialized: BOOLEAN,
|
||
|
||
SsHandle: PVOID,
|
||
InLoadOrderModuleList: LIST_ENTRY,
|
||
InMemoryOrderModuleList: LIST_ENTRY,
|
||
InInitializationOrderModuleList: LIST_ENTRY,
|
||
|
||
// Versions: 5.1 and higher
|
||
|
||
/// No known use of this field is known in Windows 8 and higher.
|
||
EntryInProgress: PVOID,
|
||
|
||
// Versions: 6.0 from Windows Vista SP1, and higher
|
||
ShutdownInProgress: BOOLEAN,
|
||
|
||
/// Though ShutdownThreadId is declared as a HANDLE,
|
||
/// it is indeed the thread ID as suggested by its name.
|
||
/// It is picked up from the UniqueThread member of the CLIENT_ID in the
|
||
/// TEB of the thread that asks to terminate the process.
|
||
ShutdownThreadId: HANDLE,
|
||
};
|
||
|
||
/// Microsoft documentation of this is incomplete, the fields here are taken from various resources including:
|
||
/// - https://docs.microsoft.com/en-us/windows/win32/api/winternl/ns-winternl-peb_ldr_data
|
||
/// - https://www.geoffchappell.com/studies/windows/km/ntoskrnl/inc/api/ntldr/ldr_data_table_entry.htm
|
||
pub const LDR_DATA_TABLE_ENTRY = extern struct {
|
||
Reserved1: [2]PVOID,
|
||
InMemoryOrderLinks: LIST_ENTRY,
|
||
Reserved2: [2]PVOID,
|
||
DllBase: PVOID,
|
||
EntryPoint: PVOID,
|
||
SizeOfImage: ULONG,
|
||
FullDllName: UNICODE_STRING,
|
||
Reserved4: [8]BYTE,
|
||
Reserved5: [3]PVOID,
|
||
DUMMYUNIONNAME: extern union {
|
||
CheckSum: ULONG,
|
||
Reserved6: PVOID,
|
||
},
|
||
TimeDateStamp: ULONG,
|
||
};
|
||
|
||
pub const RTL_USER_PROCESS_PARAMETERS = extern struct {
|
||
AllocationSize: ULONG,
|
||
Size: ULONG,
|
||
Flags: ULONG,
|
||
DebugFlags: ULONG,
|
||
ConsoleHandle: HANDLE,
|
||
ConsoleFlags: ULONG,
|
||
hStdInput: HANDLE,
|
||
hStdOutput: HANDLE,
|
||
hStdError: HANDLE,
|
||
CurrentDirectory: CURDIR,
|
||
DllPath: UNICODE_STRING,
|
||
ImagePathName: UNICODE_STRING,
|
||
CommandLine: UNICODE_STRING,
|
||
Environment: [*:0]WCHAR,
|
||
dwX: ULONG,
|
||
dwY: ULONG,
|
||
dwXSize: ULONG,
|
||
dwYSize: ULONG,
|
||
dwXCountChars: ULONG,
|
||
dwYCountChars: ULONG,
|
||
dwFillAttribute: ULONG,
|
||
dwFlags: ULONG,
|
||
dwShowWindow: ULONG,
|
||
WindowTitle: UNICODE_STRING,
|
||
Desktop: UNICODE_STRING,
|
||
ShellInfo: UNICODE_STRING,
|
||
RuntimeInfo: UNICODE_STRING,
|
||
DLCurrentDirectory: [0x20]RTL_DRIVE_LETTER_CURDIR,
|
||
};
|
||
|
||
pub const RTL_DRIVE_LETTER_CURDIR = extern struct {
|
||
Flags: c_ushort,
|
||
Length: c_ushort,
|
||
TimeStamp: ULONG,
|
||
DosPath: UNICODE_STRING,
|
||
};
|
||
|
||
pub const PPS_POST_PROCESS_INIT_ROUTINE = ?*const fn () callconv(.C) void;
|
||
|
||
pub const FILE_DIRECTORY_INFORMATION = extern struct {
|
||
NextEntryOffset: ULONG,
|
||
FileIndex: ULONG,
|
||
CreationTime: LARGE_INTEGER,
|
||
LastAccessTime: LARGE_INTEGER,
|
||
LastWriteTime: LARGE_INTEGER,
|
||
ChangeTime: LARGE_INTEGER,
|
||
EndOfFile: LARGE_INTEGER,
|
||
AllocationSize: LARGE_INTEGER,
|
||
FileAttributes: ULONG,
|
||
FileNameLength: ULONG,
|
||
FileName: [1]WCHAR,
|
||
};
|
||
|
||
pub const FILE_BOTH_DIR_INFORMATION = extern struct {
|
||
NextEntryOffset: ULONG,
|
||
FileIndex: ULONG,
|
||
CreationTime: LARGE_INTEGER,
|
||
LastAccessTime: LARGE_INTEGER,
|
||
LastWriteTime: LARGE_INTEGER,
|
||
ChangeTime: LARGE_INTEGER,
|
||
EndOfFile: LARGE_INTEGER,
|
||
AllocationSize: LARGE_INTEGER,
|
||
FileAttributes: ULONG,
|
||
FileNameLength: ULONG,
|
||
EaSize: ULONG,
|
||
ShortNameLength: CHAR,
|
||
ShortName: [12]WCHAR,
|
||
FileName: [1]WCHAR,
|
||
};
|
||
pub const FILE_BOTH_DIRECTORY_INFORMATION = FILE_BOTH_DIR_INFORMATION;
|
||
|
||
/// Helper for iterating a byte buffer of FILE_*_INFORMATION structures (from
|
||
/// things like NtQueryDirectoryFile calls).
|
||
pub fn FileInformationIterator(comptime FileInformationType: type) type {
|
||
return struct {
|
||
byte_offset: usize = 0,
|
||
buf: []u8 align(@alignOf(FileInformationType)),
|
||
|
||
pub fn next(self: *@This()) ?*FileInformationType {
|
||
if (self.byte_offset >= self.buf.len) return null;
|
||
const cur: *FileInformationType = @ptrCast(@alignCast(&self.buf[self.byte_offset]));
|
||
if (cur.NextEntryOffset == 0) {
|
||
self.byte_offset = self.buf.len;
|
||
} else {
|
||
self.byte_offset += cur.NextEntryOffset;
|
||
}
|
||
return cur;
|
||
}
|
||
};
|
||
}
|
||
|
||
pub const IO_APC_ROUTINE = *const fn (PVOID, *IO_STATUS_BLOCK, ULONG) callconv(.C) void;
|
||
|
||
pub const CURDIR = extern struct {
|
||
DosPath: UNICODE_STRING,
|
||
Handle: HANDLE,
|
||
};
|
||
|
||
pub const DUPLICATE_SAME_ACCESS = 2;
|
||
|
||
pub const MODULEINFO = extern struct {
|
||
lpBaseOfDll: LPVOID,
|
||
SizeOfImage: DWORD,
|
||
EntryPoint: LPVOID,
|
||
};
|
||
|
||
pub const PSAPI_WS_WATCH_INFORMATION = extern struct {
|
||
FaultingPc: LPVOID,
|
||
FaultingVa: LPVOID,
|
||
};
|
||
|
||
pub const VM_COUNTERS = extern struct {
|
||
PeakVirtualSize: SIZE_T,
|
||
VirtualSize: SIZE_T,
|
||
PageFaultCount: ULONG,
|
||
PeakWorkingSetSize: SIZE_T,
|
||
WorkingSetSize: SIZE_T,
|
||
QuotaPeakPagedPoolUsage: SIZE_T,
|
||
QuotaPagedPoolUsage: SIZE_T,
|
||
QuotaPeakNonPagedPoolUsage: SIZE_T,
|
||
QuotaNonPagedPoolUsage: SIZE_T,
|
||
PagefileUsage: SIZE_T,
|
||
PeakPagefileUsage: SIZE_T,
|
||
};
|
||
|
||
pub const PROCESS_MEMORY_COUNTERS = extern struct {
|
||
cb: DWORD,
|
||
PageFaultCount: DWORD,
|
||
PeakWorkingSetSize: SIZE_T,
|
||
WorkingSetSize: SIZE_T,
|
||
QuotaPeakPagedPoolUsage: SIZE_T,
|
||
QuotaPagedPoolUsage: SIZE_T,
|
||
QuotaPeakNonPagedPoolUsage: SIZE_T,
|
||
QuotaNonPagedPoolUsage: SIZE_T,
|
||
PagefileUsage: SIZE_T,
|
||
PeakPagefileUsage: SIZE_T,
|
||
};
|
||
|
||
pub const PROCESS_MEMORY_COUNTERS_EX = extern struct {
|
||
cb: DWORD,
|
||
PageFaultCount: DWORD,
|
||
PeakWorkingSetSize: SIZE_T,
|
||
WorkingSetSize: SIZE_T,
|
||
QuotaPeakPagedPoolUsage: SIZE_T,
|
||
QuotaPagedPoolUsage: SIZE_T,
|
||
QuotaPeakNonPagedPoolUsage: SIZE_T,
|
||
QuotaNonPagedPoolUsage: SIZE_T,
|
||
PagefileUsage: SIZE_T,
|
||
PeakPagefileUsage: SIZE_T,
|
||
PrivateUsage: SIZE_T,
|
||
};
|
||
|
||
pub const GetProcessMemoryInfoError = error{
|
||
AccessDenied,
|
||
InvalidHandle,
|
||
Unexpected,
|
||
};
|
||
|
||
pub fn GetProcessMemoryInfo(hProcess: HANDLE) GetProcessMemoryInfoError!VM_COUNTERS {
|
||
var vmc: VM_COUNTERS = undefined;
|
||
const rc = ntdll.NtQueryInformationProcess(hProcess, .ProcessVmCounters, &vmc, @sizeOf(VM_COUNTERS), null);
|
||
switch (rc) {
|
||
.SUCCESS => return vmc,
|
||
.ACCESS_DENIED => return error.AccessDenied,
|
||
.INVALID_HANDLE => return error.InvalidHandle,
|
||
.INVALID_PARAMETER => unreachable,
|
||
else => return unexpectedStatus(rc),
|
||
}
|
||
}
|
||
|
||
pub const PERFORMANCE_INFORMATION = extern struct {
|
||
cb: DWORD,
|
||
CommitTotal: SIZE_T,
|
||
CommitLimit: SIZE_T,
|
||
CommitPeak: SIZE_T,
|
||
PhysicalTotal: SIZE_T,
|
||
PhysicalAvailable: SIZE_T,
|
||
SystemCache: SIZE_T,
|
||
KernelTotal: SIZE_T,
|
||
KernelPaged: SIZE_T,
|
||
KernelNonpaged: SIZE_T,
|
||
PageSize: SIZE_T,
|
||
HandleCount: DWORD,
|
||
ProcessCount: DWORD,
|
||
ThreadCount: DWORD,
|
||
};
|
||
|
||
pub const ENUM_PAGE_FILE_INFORMATION = extern struct {
|
||
cb: DWORD,
|
||
Reserved: DWORD,
|
||
TotalSize: SIZE_T,
|
||
TotalInUse: SIZE_T,
|
||
PeakUsage: SIZE_T,
|
||
};
|
||
|
||
pub const PENUM_PAGE_FILE_CALLBACKW = ?*const fn (?LPVOID, *ENUM_PAGE_FILE_INFORMATION, LPCWSTR) callconv(.C) BOOL;
|
||
pub const PENUM_PAGE_FILE_CALLBACKA = ?*const fn (?LPVOID, *ENUM_PAGE_FILE_INFORMATION, LPCSTR) callconv(.C) BOOL;
|
||
|
||
pub const PSAPI_WS_WATCH_INFORMATION_EX = extern struct {
|
||
BasicInfo: PSAPI_WS_WATCH_INFORMATION,
|
||
FaultingThreadId: ULONG_PTR,
|
||
Flags: ULONG_PTR,
|
||
};
|
||
|
||
pub const OSVERSIONINFOW = extern struct {
|
||
dwOSVersionInfoSize: ULONG,
|
||
dwMajorVersion: ULONG,
|
||
dwMinorVersion: ULONG,
|
||
dwBuildNumber: ULONG,
|
||
dwPlatformId: ULONG,
|
||
szCSDVersion: [128]WCHAR,
|
||
};
|
||
pub const RTL_OSVERSIONINFOW = OSVERSIONINFOW;
|
||
|
||
pub const REPARSE_DATA_BUFFER = extern struct {
|
||
ReparseTag: ULONG,
|
||
ReparseDataLength: USHORT,
|
||
Reserved: USHORT,
|
||
DataBuffer: [1]UCHAR,
|
||
};
|
||
pub const SYMBOLIC_LINK_REPARSE_BUFFER = extern struct {
|
||
SubstituteNameOffset: USHORT,
|
||
SubstituteNameLength: USHORT,
|
||
PrintNameOffset: USHORT,
|
||
PrintNameLength: USHORT,
|
||
Flags: ULONG,
|
||
PathBuffer: [1]WCHAR,
|
||
};
|
||
pub const MOUNT_POINT_REPARSE_BUFFER = extern struct {
|
||
SubstituteNameOffset: USHORT,
|
||
SubstituteNameLength: USHORT,
|
||
PrintNameOffset: USHORT,
|
||
PrintNameLength: USHORT,
|
||
PathBuffer: [1]WCHAR,
|
||
};
|
||
pub const MAXIMUM_REPARSE_DATA_BUFFER_SIZE: ULONG = 16 * 1024;
|
||
pub const FSCTL_SET_REPARSE_POINT: DWORD = 0x900a4;
|
||
pub const FSCTL_GET_REPARSE_POINT: DWORD = 0x900a8;
|
||
pub const IO_REPARSE_TAG_SYMLINK: ULONG = 0xa000000c;
|
||
pub const IO_REPARSE_TAG_MOUNT_POINT: ULONG = 0xa0000003;
|
||
pub const SYMLINK_FLAG_RELATIVE: ULONG = 0x1;
|
||
|
||
pub const SYMBOLIC_LINK_FLAG_DIRECTORY: DWORD = 0x1;
|
||
pub const SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE: DWORD = 0x2;
|
||
|
||
pub const MOUNTMGRCONTROLTYPE = 0x0000006D;
|
||
|
||
pub const MOUNTMGR_MOUNT_POINT = extern struct {
|
||
SymbolicLinkNameOffset: ULONG,
|
||
SymbolicLinkNameLength: USHORT,
|
||
Reserved1: USHORT,
|
||
UniqueIdOffset: ULONG,
|
||
UniqueIdLength: USHORT,
|
||
Reserved2: USHORT,
|
||
DeviceNameOffset: ULONG,
|
||
DeviceNameLength: USHORT,
|
||
Reserved3: USHORT,
|
||
};
|
||
pub const MOUNTMGR_MOUNT_POINTS = extern struct {
|
||
Size: ULONG,
|
||
NumberOfMountPoints: ULONG,
|
||
MountPoints: [1]MOUNTMGR_MOUNT_POINT,
|
||
};
|
||
pub const IOCTL_MOUNTMGR_QUERY_POINTS = CTL_CODE(MOUNTMGRCONTROLTYPE, 2, .METHOD_BUFFERED, FILE_ANY_ACCESS);
|
||
|
||
pub const MOUNTMGR_TARGET_NAME = extern struct {
|
||
DeviceNameLength: USHORT,
|
||
DeviceName: [1]WCHAR,
|
||
};
|
||
pub const MOUNTMGR_VOLUME_PATHS = extern struct {
|
||
MultiSzLength: ULONG,
|
||
MultiSz: [1]WCHAR,
|
||
};
|
||
pub const IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH = CTL_CODE(MOUNTMGRCONTROLTYPE, 12, .METHOD_BUFFERED, FILE_ANY_ACCESS);
|
||
|
||
pub const OBJECT_INFORMATION_CLASS = enum(c_int) {
|
||
ObjectBasicInformation = 0,
|
||
ObjectNameInformation = 1,
|
||
ObjectTypeInformation = 2,
|
||
ObjectTypesInformation = 3,
|
||
ObjectHandleFlagInformation = 4,
|
||
ObjectSessionInformation = 5,
|
||
MaxObjectInfoClass,
|
||
};
|
||
|
||
pub const OBJECT_NAME_INFORMATION = extern struct {
|
||
Name: UNICODE_STRING,
|
||
};
|
||
|
||
pub const SRWLOCK_INIT = SRWLOCK{};
|
||
pub const SRWLOCK = extern struct {
|
||
Ptr: ?PVOID = null,
|
||
};
|
||
|
||
pub const CONDITION_VARIABLE_INIT = CONDITION_VARIABLE{};
|
||
pub const CONDITION_VARIABLE = extern struct {
|
||
Ptr: ?PVOID = null,
|
||
};
|
||
|
||
pub const FILE_SKIP_COMPLETION_PORT_ON_SUCCESS = 0x1;
|
||
pub const FILE_SKIP_SET_EVENT_ON_HANDLE = 0x2;
|
||
|
||
pub const CTRL_C_EVENT: DWORD = 0;
|
||
pub const CTRL_BREAK_EVENT: DWORD = 1;
|
||
pub const CTRL_CLOSE_EVENT: DWORD = 2;
|
||
pub const CTRL_LOGOFF_EVENT: DWORD = 5;
|
||
pub const CTRL_SHUTDOWN_EVENT: DWORD = 6;
|
||
|
||
pub const HANDLER_ROUTINE = *const fn (dwCtrlType: DWORD) callconv(WINAPI) BOOL;
|
||
|
||
/// Processor feature enumeration.
|
||
pub const PF = enum(DWORD) {
|
||
/// On a Pentium, a floating-point precision error can occur in rare circumstances.
|
||
FLOATING_POINT_PRECISION_ERRATA = 0,
|
||
|
||
/// Floating-point operations are emulated using software emulator.
|
||
/// This function returns a nonzero value if floating-point operations are emulated; otherwise, it returns zero.
|
||
FLOATING_POINT_EMULATED = 1,
|
||
|
||
/// The atomic compare and exchange operation (cmpxchg) is available.
|
||
COMPARE_EXCHANGE_DOUBLE = 2,
|
||
|
||
/// The MMX instruction set is available.
|
||
MMX_INSTRUCTIONS_AVAILABLE = 3,
|
||
|
||
PPC_MOVEMEM_64BIT_OK = 4,
|
||
ALPHA_BYTE_INSTRUCTIONS = 5,
|
||
|
||
/// The SSE instruction set is available.
|
||
XMMI_INSTRUCTIONS_AVAILABLE = 6,
|
||
|
||
/// The 3D-Now instruction is available.
|
||
@"3DNOW_INSTRUCTIONS_AVAILABLE" = 7,
|
||
|
||
/// The RDTSC instruction is available.
|
||
RDTSC_INSTRUCTION_AVAILABLE = 8,
|
||
|
||
/// The processor is PAE-enabled.
|
||
PAE_ENABLED = 9,
|
||
|
||
/// The SSE2 instruction set is available.
|
||
XMMI64_INSTRUCTIONS_AVAILABLE = 10,
|
||
|
||
SSE_DAZ_MODE_AVAILABLE = 11,
|
||
|
||
/// Data execution prevention is enabled.
|
||
NX_ENABLED = 12,
|
||
|
||
/// The SSE3 instruction set is available.
|
||
SSE3_INSTRUCTIONS_AVAILABLE = 13,
|
||
|
||
/// The atomic compare and exchange 128-bit operation (cmpxchg16b) is available.
|
||
COMPARE_EXCHANGE128 = 14,
|
||
|
||
/// The atomic compare 64 and exchange 128-bit operation (cmp8xchg16) is available.
|
||
COMPARE64_EXCHANGE128 = 15,
|
||
|
||
/// The processor channels are enabled.
|
||
CHANNELS_ENABLED = 16,
|
||
|
||
/// The processor implements the XSAVI and XRSTOR instructions.
|
||
XSAVE_ENABLED = 17,
|
||
|
||
/// The VFP/Neon: 32 x 64bit register bank is present.
|
||
/// This flag has the same meaning as PF_ARM_VFP_EXTENDED_REGISTERS.
|
||
ARM_VFP_32_REGISTERS_AVAILABLE = 18,
|
||
|
||
/// This ARM processor implements the ARM v8 NEON instruction set.
|
||
ARM_NEON_INSTRUCTIONS_AVAILABLE = 19,
|
||
|
||
/// Second Level Address Translation is supported by the hardware.
|
||
SECOND_LEVEL_ADDRESS_TRANSLATION = 20,
|
||
|
||
/// Virtualization is enabled in the firmware and made available by the operating system.
|
||
VIRT_FIRMWARE_ENABLED = 21,
|
||
|
||
/// RDFSBASE, RDGSBASE, WRFSBASE, and WRGSBASE instructions are available.
|
||
RDWRFSGBASE_AVAILABLE = 22,
|
||
|
||
/// _fastfail() is available.
|
||
FASTFAIL_AVAILABLE = 23,
|
||
|
||
/// The divide instruction_available.
|
||
ARM_DIVIDE_INSTRUCTION_AVAILABLE = 24,
|
||
|
||
/// The 64-bit load/store atomic instructions are available.
|
||
ARM_64BIT_LOADSTORE_ATOMIC = 25,
|
||
|
||
/// The external cache is available.
|
||
ARM_EXTERNAL_CACHE_AVAILABLE = 26,
|
||
|
||
/// The floating-point multiply-accumulate instruction is available.
|
||
ARM_FMAC_INSTRUCTIONS_AVAILABLE = 27,
|
||
|
||
RDRAND_INSTRUCTION_AVAILABLE = 28,
|
||
|
||
/// This ARM processor implements the ARM v8 instructions set.
|
||
ARM_V8_INSTRUCTIONS_AVAILABLE = 29,
|
||
|
||
/// This ARM processor implements the ARM v8 extra cryptographic instructions (i.e., AES, SHA1 and SHA2).
|
||
ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE = 30,
|
||
|
||
/// This ARM processor implements the ARM v8 extra CRC32 instructions.
|
||
ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE = 31,
|
||
|
||
RDTSCP_INSTRUCTION_AVAILABLE = 32,
|
||
RDPID_INSTRUCTION_AVAILABLE = 33,
|
||
|
||
/// This ARM processor implements the ARM v8.1 atomic instructions (e.g., CAS, SWP).
|
||
ARM_V81_ATOMIC_INSTRUCTIONS_AVAILABLE = 34,
|
||
|
||
MONITORX_INSTRUCTION_AVAILABLE = 35,
|
||
|
||
/// The SSSE3 instruction set is available.
|
||
SSSE3_INSTRUCTIONS_AVAILABLE = 36,
|
||
|
||
/// The SSE4_1 instruction set is available.
|
||
SSE4_1_INSTRUCTIONS_AVAILABLE = 37,
|
||
|
||
/// The SSE4_2 instruction set is available.
|
||
SSE4_2_INSTRUCTIONS_AVAILABLE = 38,
|
||
|
||
/// The AVX instruction set is available.
|
||
AVX_INSTRUCTIONS_AVAILABLE = 39,
|
||
|
||
/// The AVX2 instruction set is available.
|
||
AVX2_INSTRUCTIONS_AVAILABLE = 40,
|
||
|
||
/// The AVX512F instruction set is available.
|
||
AVX512F_INSTRUCTIONS_AVAILABLE = 41,
|
||
|
||
ERMS_AVAILABLE = 42,
|
||
|
||
/// This ARM processor implements the ARM v8.2 Dot Product (DP) instructions.
|
||
ARM_V82_DP_INSTRUCTIONS_AVAILABLE = 43,
|
||
|
||
/// This ARM processor implements the ARM v8.3 JavaScript conversion (JSCVT) instructions.
|
||
ARM_V83_JSCVT_INSTRUCTIONS_AVAILABLE = 44,
|
||
};
|
||
|
||
pub const MAX_WOW64_SHARED_ENTRIES = 16;
|
||
pub const PROCESSOR_FEATURE_MAX = 64;
|
||
pub const MAXIMUM_XSTATE_FEATURES = 64;
|
||
|
||
pub const KSYSTEM_TIME = extern struct {
|
||
LowPart: ULONG,
|
||
High1Time: LONG,
|
||
High2Time: LONG,
|
||
};
|
||
|
||
pub const NT_PRODUCT_TYPE = enum(INT) {
|
||
NtProductWinNt = 1,
|
||
NtProductLanManNt,
|
||
NtProductServer,
|
||
};
|
||
|
||
pub const ALTERNATIVE_ARCHITECTURE_TYPE = enum(INT) {
|
||
StandardDesign,
|
||
NEC98x86,
|
||
EndAlternatives,
|
||
};
|
||
|
||
pub const XSTATE_FEATURE = extern struct {
|
||
Offset: ULONG,
|
||
Size: ULONG,
|
||
};
|
||
|
||
pub const XSTATE_CONFIGURATION = extern struct {
|
||
EnabledFeatures: ULONG64,
|
||
Size: ULONG,
|
||
OptimizedSave: ULONG,
|
||
Features: [MAXIMUM_XSTATE_FEATURES]XSTATE_FEATURE,
|
||
};
|
||
|
||
/// Shared Kernel User Data
|
||
pub const KUSER_SHARED_DATA = extern struct {
|
||
TickCountLowDeprecated: ULONG,
|
||
TickCountMultiplier: ULONG,
|
||
InterruptTime: KSYSTEM_TIME,
|
||
SystemTime: KSYSTEM_TIME,
|
||
TimeZoneBias: KSYSTEM_TIME,
|
||
ImageNumberLow: USHORT,
|
||
ImageNumberHigh: USHORT,
|
||
NtSystemRoot: [260]WCHAR,
|
||
MaxStackTraceDepth: ULONG,
|
||
CryptoExponent: ULONG,
|
||
TimeZoneId: ULONG,
|
||
LargePageMinimum: ULONG,
|
||
AitSamplingValue: ULONG,
|
||
AppCompatFlag: ULONG,
|
||
RNGSeedVersion: ULONGLONG,
|
||
GlobalValidationRunlevel: ULONG,
|
||
TimeZoneBiasStamp: LONG,
|
||
NtBuildNumber: ULONG,
|
||
NtProductType: NT_PRODUCT_TYPE,
|
||
ProductTypeIsValid: BOOLEAN,
|
||
Reserved0: [1]BOOLEAN,
|
||
NativeProcessorArchitecture: USHORT,
|
||
NtMajorVersion: ULONG,
|
||
NtMinorVersion: ULONG,
|
||
ProcessorFeatures: [PROCESSOR_FEATURE_MAX]BOOLEAN,
|
||
Reserved1: ULONG,
|
||
Reserved3: ULONG,
|
||
TimeSlip: ULONG,
|
||
AlternativeArchitecture: ALTERNATIVE_ARCHITECTURE_TYPE,
|
||
BootId: ULONG,
|
||
SystemExpirationDate: LARGE_INTEGER,
|
||
SuiteMaskY: ULONG,
|
||
KdDebuggerEnabled: BOOLEAN,
|
||
DummyUnion1: extern union {
|
||
MitigationPolicies: UCHAR,
|
||
Alt: packed struct {
|
||
NXSupportPolicy: u2,
|
||
SEHValidationPolicy: u2,
|
||
CurDirDevicesSkippedForDlls: u2,
|
||
Reserved: u2,
|
||
},
|
||
},
|
||
CyclesPerYield: USHORT,
|
||
ActiveConsoleId: ULONG,
|
||
DismountCount: ULONG,
|
||
ComPlusPackage: ULONG,
|
||
LastSystemRITEventTickCount: ULONG,
|
||
NumberOfPhysicalPages: ULONG,
|
||
SafeBootMode: BOOLEAN,
|
||
DummyUnion2: extern union {
|
||
VirtualizationFlags: UCHAR,
|
||
Alt: packed struct {
|
||
ArchStartedInEl2: u1,
|
||
QcSlIsSupported: u1,
|
||
SpareBits: u6,
|
||
},
|
||
},
|
||
Reserved12: [2]UCHAR,
|
||
DummyUnion3: extern union {
|
||
SharedDataFlags: ULONG,
|
||
Alt: packed struct {
|
||
DbgErrorPortPresent: u1,
|
||
DbgElevationEnabled: u1,
|
||
DbgVirtEnabled: u1,
|
||
DbgInstallerDetectEnabled: u1,
|
||
DbgLkgEnabled: u1,
|
||
DbgDynProcessorEnabled: u1,
|
||
DbgConsoleBrokerEnabled: u1,
|
||
DbgSecureBootEnabled: u1,
|
||
DbgMultiSessionSku: u1,
|
||
DbgMultiUsersInSessionSku: u1,
|
||
DbgStateSeparationEnabled: u1,
|
||
SpareBits: u21,
|
||
},
|
||
},
|
||
DataFlagsPad: [1]ULONG,
|
||
TestRetInstruction: ULONGLONG,
|
||
QpcFrequency: LONGLONG,
|
||
SystemCall: ULONG,
|
||
Reserved2: ULONG,
|
||
SystemCallPad: [2]ULONGLONG,
|
||
DummyUnion4: extern union {
|
||
TickCount: KSYSTEM_TIME,
|
||
TickCountQuad: ULONG64,
|
||
Alt: extern struct {
|
||
ReservedTickCountOverlay: [3]ULONG,
|
||
TickCountPad: [1]ULONG,
|
||
},
|
||
},
|
||
Cookie: ULONG,
|
||
CookiePad: [1]ULONG,
|
||
ConsoleSessionForegroundProcessId: LONGLONG,
|
||
TimeUpdateLock: ULONGLONG,
|
||
BaselineSystemTimeQpc: ULONGLONG,
|
||
BaselineInterruptTimeQpc: ULONGLONG,
|
||
QpcSystemTimeIncrement: ULONGLONG,
|
||
QpcInterruptTimeIncrement: ULONGLONG,
|
||
QpcSystemTimeIncrementShift: UCHAR,
|
||
QpcInterruptTimeIncrementShift: UCHAR,
|
||
UnparkedProcessorCount: USHORT,
|
||
EnclaveFeatureMask: [4]ULONG,
|
||
TelemetryCoverageRound: ULONG,
|
||
UserModeGlobalLogger: [16]USHORT,
|
||
ImageFileExecutionOptions: ULONG,
|
||
LangGenerationCount: ULONG,
|
||
Reserved4: ULONGLONG,
|
||
InterruptTimeBias: ULONGLONG,
|
||
QpcBias: ULONGLONG,
|
||
ActiveProcessorCount: ULONG,
|
||
ActiveGroupCount: UCHAR,
|
||
Reserved9: UCHAR,
|
||
DummyUnion5: extern union {
|
||
QpcData: USHORT,
|
||
Alt: extern struct {
|
||
QpcBypassEnabled: UCHAR,
|
||
QpcShift: UCHAR,
|
||
},
|
||
},
|
||
TimeZoneBiasEffectiveStart: LARGE_INTEGER,
|
||
TimeZoneBiasEffectiveEnd: LARGE_INTEGER,
|
||
XState: XSTATE_CONFIGURATION,
|
||
FeatureConfigurationChangeStamp: KSYSTEM_TIME,
|
||
Spare: ULONG,
|
||
UserPointerAuthMask: ULONG64,
|
||
};
|
||
|
||
/// Read-only user-mode address for the shared data.
|
||
/// https://www.geoffchappell.com/studies/windows/km/ntoskrnl/inc/api/ntexapi_x/kuser_shared_data/index.htm
|
||
/// https://msrc-blog.microsoft.com/2022/04/05/randomizing-the-kuser_shared_data-structure-on-windows/
|
||
pub const SharedUserData: *const KUSER_SHARED_DATA = @as(*const KUSER_SHARED_DATA, @ptrFromInt(0x7FFE0000));
|
||
|
||
pub fn IsProcessorFeaturePresent(feature: PF) bool {
|
||
if (@intFromEnum(feature) >= PROCESSOR_FEATURE_MAX) return false;
|
||
return SharedUserData.ProcessorFeatures[@intFromEnum(feature)] == 1;
|
||
}
|
||
|
||
pub const TH32CS_SNAPHEAPLIST = 0x00000001;
|
||
pub const TH32CS_SNAPPROCESS = 0x00000002;
|
||
pub const TH32CS_SNAPTHREAD = 0x00000004;
|
||
pub const TH32CS_SNAPMODULE = 0x00000008;
|
||
pub const TH32CS_SNAPMODULE32 = 0x00000010;
|
||
pub const TH32CS_SNAPALL = TH32CS_SNAPHEAPLIST | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD | TH32CS_SNAPMODULE;
|
||
pub const TH32CS_INHERIT = 0x80000000;
|
||
|
||
pub const MAX_MODULE_NAME32 = 255;
|
||
pub const MODULEENTRY32 = extern struct {
|
||
dwSize: DWORD,
|
||
th32ModuleID: DWORD,
|
||
th32ProcessID: DWORD,
|
||
GlblcntUsage: DWORD,
|
||
ProccntUsage: DWORD,
|
||
modBaseAddr: *BYTE,
|
||
modBaseSize: DWORD,
|
||
hModule: HMODULE,
|
||
szModule: [MAX_MODULE_NAME32 + 1]CHAR,
|
||
szExePath: [MAX_PATH]CHAR,
|
||
};
|
||
|
||
pub const SYSTEM_INFORMATION_CLASS = enum(c_int) {
|
||
SystemBasicInformation = 0,
|
||
SystemPerformanceInformation = 2,
|
||
SystemTimeOfDayInformation = 3,
|
||
SystemProcessInformation = 5,
|
||
SystemProcessorPerformanceInformation = 8,
|
||
SystemInterruptInformation = 23,
|
||
SystemExceptionInformation = 33,
|
||
SystemRegistryQuotaInformation = 37,
|
||
SystemLookasideInformation = 45,
|
||
SystemCodeIntegrityInformation = 103,
|
||
SystemPolicyInformation = 134,
|
||
};
|
||
|
||
pub const SYSTEM_BASIC_INFORMATION = extern struct {
|
||
Reserved: ULONG,
|
||
TimerResolution: ULONG,
|
||
PageSize: ULONG,
|
||
NumberOfPhysicalPages: ULONG,
|
||
LowestPhysicalPageNumber: ULONG,
|
||
HighestPhysicalPageNumber: ULONG,
|
||
AllocationGranularity: ULONG,
|
||
MinimumUserModeAddress: ULONG_PTR,
|
||
MaximumUserModeAddress: ULONG_PTR,
|
||
ActiveProcessorsAffinityMask: KAFFINITY,
|
||
NumberOfProcessors: UCHAR,
|
||
};
|
||
|
||
pub const THREADINFOCLASS = enum(c_int) {
|
||
ThreadBasicInformation,
|
||
ThreadTimes,
|
||
ThreadPriority,
|
||
ThreadBasePriority,
|
||
ThreadAffinityMask,
|
||
ThreadImpersonationToken,
|
||
ThreadDescriptorTableEntry,
|
||
ThreadEnableAlignmentFaultFixup,
|
||
ThreadEventPair_Reusable,
|
||
ThreadQuerySetWin32StartAddress,
|
||
ThreadZeroTlsCell,
|
||
ThreadPerformanceCount,
|
||
ThreadAmILastThread,
|
||
ThreadIdealProcessor,
|
||
ThreadPriorityBoost,
|
||
ThreadSetTlsArrayAddress,
|
||
ThreadIsIoPending,
|
||
// Windows 2000+ from here
|
||
ThreadHideFromDebugger,
|
||
// Windows XP+ from here
|
||
ThreadBreakOnTermination,
|
||
ThreadSwitchLegacyState,
|
||
ThreadIsTerminated,
|
||
// Windows Vista+ from here
|
||
ThreadLastSystemCall,
|
||
ThreadIoPriority,
|
||
ThreadCycleTime,
|
||
ThreadPagePriority,
|
||
ThreadActualBasePriority,
|
||
ThreadTebInformation,
|
||
ThreadCSwitchMon,
|
||
// Windows 7+ from here
|
||
ThreadCSwitchPmu,
|
||
ThreadWow64Context,
|
||
ThreadGroupInformation,
|
||
ThreadUmsInformation,
|
||
ThreadCounterProfiling,
|
||
ThreadIdealProcessorEx,
|
||
// Windows 8+ from here
|
||
ThreadCpuAccountingInformation,
|
||
// Windows 8.1+ from here
|
||
ThreadSuspendCount,
|
||
// Windows 10+ from here
|
||
ThreadHeterogeneousCpuPolicy,
|
||
ThreadContainerId,
|
||
ThreadNameInformation,
|
||
ThreadSelectedCpuSets,
|
||
ThreadSystemThreadInformation,
|
||
ThreadActualGroupAffinity,
|
||
};
|
||
|
||
pub const PROCESSINFOCLASS = enum(c_int) {
|
||
ProcessBasicInformation,
|
||
ProcessQuotaLimits,
|
||
ProcessIoCounters,
|
||
ProcessVmCounters,
|
||
ProcessTimes,
|
||
ProcessBasePriority,
|
||
ProcessRaisePriority,
|
||
ProcessDebugPort,
|
||
ProcessExceptionPort,
|
||
ProcessAccessToken,
|
||
ProcessLdtInformation,
|
||
ProcessLdtSize,
|
||
ProcessDefaultHardErrorMode,
|
||
ProcessIoPortHandlers,
|
||
ProcessPooledUsageAndLimits,
|
||
ProcessWorkingSetWatch,
|
||
ProcessUserModeIOPL,
|
||
ProcessEnableAlignmentFaultFixup,
|
||
ProcessPriorityClass,
|
||
ProcessWx86Information,
|
||
ProcessHandleCount,
|
||
ProcessAffinityMask,
|
||
ProcessPriorityBoost,
|
||
ProcessDeviceMap,
|
||
ProcessSessionInformation,
|
||
ProcessForegroundInformation,
|
||
ProcessWow64Information,
|
||
ProcessImageFileName,
|
||
ProcessLUIDDeviceMapsEnabled,
|
||
ProcessBreakOnTermination,
|
||
ProcessDebugObjectHandle,
|
||
ProcessDebugFlags,
|
||
ProcessHandleTracing,
|
||
ProcessIoPriority,
|
||
ProcessExecuteFlags,
|
||
ProcessTlsInformation,
|
||
ProcessCookie,
|
||
ProcessImageInformation,
|
||
ProcessCycleTime,
|
||
ProcessPagePriority,
|
||
ProcessInstrumentationCallback,
|
||
ProcessThreadStackAllocation,
|
||
ProcessWorkingSetWatchEx,
|
||
ProcessImageFileNameWin32,
|
||
ProcessImageFileMapping,
|
||
ProcessAffinityUpdateMode,
|
||
ProcessMemoryAllocationMode,
|
||
ProcessGroupInformation,
|
||
ProcessTokenVirtualizationEnabled,
|
||
ProcessConsoleHostProcess,
|
||
ProcessWindowInformation,
|
||
MaxProcessInfoClass,
|
||
};
|
||
|
||
pub const PROCESS_BASIC_INFORMATION = extern struct {
|
||
ExitStatus: NTSTATUS,
|
||
PebBaseAddress: *PEB,
|
||
AffinityMask: ULONG_PTR,
|
||
BasePriority: KPRIORITY,
|
||
UniqueProcessId: ULONG_PTR,
|
||
InheritedFromUniqueProcessId: ULONG_PTR,
|
||
};
|
||
|
||
pub const ReadMemoryError = error{
|
||
Unexpected,
|
||
};
|
||
|
||
pub fn ReadProcessMemory(handle: HANDLE, addr: ?LPVOID, buffer: []u8) ReadMemoryError![]u8 {
|
||
var nread: usize = 0;
|
||
switch (ntdll.NtReadVirtualMemory(
|
||
handle,
|
||
addr,
|
||
buffer.ptr,
|
||
buffer.len,
|
||
&nread,
|
||
)) {
|
||
.SUCCESS => return buffer[0..nread],
|
||
// TODO: map errors
|
||
else => |rc| return unexpectedStatus(rc),
|
||
}
|
||
}
|
||
|
||
pub const WriteMemoryError = error{
|
||
Unexpected,
|
||
};
|
||
|
||
pub fn WriteProcessMemory(handle: HANDLE, addr: ?LPVOID, buffer: []const u8) WriteMemoryError!usize {
|
||
var nwritten: usize = 0;
|
||
switch (ntdll.NtWriteVirtualMemory(
|
||
handle,
|
||
addr,
|
||
buffer.ptr,
|
||
buffer.len,
|
||
&nwritten,
|
||
)) {
|
||
.SUCCESS => return nwritten,
|
||
// TODO: map errors
|
||
else => |rc| return unexpectedStatus(rc),
|
||
}
|
||
}
|
||
|
||
pub const ProcessBaseAddressError = GetProcessMemoryInfoError || ReadMemoryError;
|
||
|
||
/// Returns the base address of the process loaded into memory.
|
||
pub fn ProcessBaseAddress(handle: HANDLE) ProcessBaseAddressError!HMODULE {
|
||
var info: PROCESS_BASIC_INFORMATION = undefined;
|
||
var nread: DWORD = 0;
|
||
const rc = ntdll.NtQueryInformationProcess(
|
||
handle,
|
||
.ProcessBasicInformation,
|
||
&info,
|
||
@sizeOf(PROCESS_BASIC_INFORMATION),
|
||
&nread,
|
||
);
|
||
switch (rc) {
|
||
.SUCCESS => {},
|
||
.ACCESS_DENIED => return error.AccessDenied,
|
||
.INVALID_HANDLE => return error.InvalidHandle,
|
||
.INVALID_PARAMETER => unreachable,
|
||
else => return unexpectedStatus(rc),
|
||
}
|
||
|
||
var peb_buf: [@sizeOf(PEB)]u8 align(@alignOf(PEB)) = undefined;
|
||
const peb_out = try ReadProcessMemory(handle, info.PebBaseAddress, &peb_buf);
|
||
const ppeb: *const PEB = @ptrCast(@alignCast(peb_out.ptr));
|
||
return ppeb.ImageBaseAddress;
|
||
}
|