authorgravatar for dev@sgregoratto.meStephen Gregoratto <dev@sgregoratto.me> 2024-04-13 15:28:12+10:00
committergravatar for dev@sgregoratto.meStephen Gregoratto <dev@sgregoratto.me> 2024-07-17 23:11:23+10:00
log3095e83d1162081ba54ed73c59810bfe0fb3f025
treeefd632f73b81439d7197c51b4a1f01eacb934a67
parent1735455099cb75acb970f549e579368e2a447405

Windows: Rework kernel32 apis

To facilitate #1840, this commit slims `std.windows.kernel32` to only have the functions needed by the standard library. Since this will break projects that relied on these, I offer two solutions: - Make an argument as to why certain functions should be added back in. Note that they may just be wrappers around `ntdll` APIs, which would go against #1840. If necessary I'll add them back in *and* make wrappers in `std.windows` for it. - Maintain your own list of APIs. This is the option taken by bun[1], where they wrap functions with tracing. - Use `zigwin32`. I've also added TODO comments that specify which functions can be reimplemented using `ntdll` APIs in the future. Other changes: - Group functions into groups (I/O, process management etc.). - Synchronize definitions against Microsoft documentation to use the proper parameter types/names. - Break all functions with parameters over multiple lines.

3 files changed, 529 insertions(+), 331 deletions(-)

lib/std/debug.zig+1-1
......@@ -1987,7 +1987,7 @@ pub const DebugInfo = struct {
19871987 @memcpy(name_buffer[0..4], &[_]u16{ '\\', '?', '?', '\\' });
19881988
19891989 const process_handle = windows.kernel32.GetCurrentProcess();
1990 const len = windows.kernel32.K32GetModuleFileNameExW(
1990 const len = windows.kernel32.GetModuleFileNameExW(
19911991 process_handle,
19921992 module.handle,
19931993 @ptrCast(&name_buffer[4]),
lib/std/os/windows.zig+3-3
......@@ -729,8 +729,8 @@ pub const GetCurrentDirectoryError = error{
729729/// The result is a slice of `buffer`, indexed from 0.
730730/// The result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
731731pub fn GetCurrentDirectory(buffer: []u8) GetCurrentDirectoryError![]u8 {
732 var wtf16le_buf: [PATH_MAX_WIDE]u16 = undefined;
733 const result = kernel32.GetCurrentDirectoryW(wtf16le_buf.len, &wtf16le_buf);
732 var wtf16le_buf: [PATH_MAX_WIDE:0]u16 = undefined;
733 const result = kernel32.GetCurrentDirectoryW(wtf16le_buf.len + 1, &wtf16le_buf);
734734 if (result == 0) {
735735 switch (GetLastError()) {
736736 else => |err| return unexpectedError(err),
......@@ -2768,7 +2768,7 @@ pub fn loadWinsockExtensionFunction(comptime T: type, sock: ws2_32.SOCKET, guid:
27682768pub fn unexpectedError(err: Win32Error) UnexpectedError {
27692769 if (std.posix.unexpected_error_tracing) {
27702770 // 614 is the length of the longest windows error description
2771 var buf_wstr: [614]WCHAR = undefined;
2771 var buf_wstr: [614:0]WCHAR = undefined;
27722772 const len = kernel32.FormatMessageW(
27732773 FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
27742774 null,
lib/std/os/windows/kernel32.zig+525-327
......@@ -5,90 +5,59 @@ const BOOL = windows.BOOL;
55const BOOLEAN = windows.BOOLEAN;
66const CONDITION_VARIABLE = windows.CONDITION_VARIABLE;
77const CONSOLE_SCREEN_BUFFER_INFO = windows.CONSOLE_SCREEN_BUFFER_INFO;
8const CONTEXT = windows.CONTEXT;
98const COORD = windows.COORD;
9const CRITICAL_SECTION = windows.CRITICAL_SECTION;
1010const DWORD = windows.DWORD;
11const DWORD64 = windows.DWORD64;
12const FILE_INFO_BY_HANDLE_CLASS = windows.FILE_INFO_BY_HANDLE_CLASS;
11const FARPROC = windows.FARPROC;
12const FILETIME = windows.FILETIME;
1313const HANDLE = windows.HANDLE;
14const HANDLER_ROUTINE = windows.HANDLER_ROUTINE;
15const HLOCAL = windows.HLOCAL;
1416const HMODULE = windows.HMODULE;
15const HKEY = windows.HKEY;
16const HRESULT = windows.HRESULT;
17const INIT_ONCE = windows.INIT_ONCE;
18const INIT_ONCE_FN = windows.INIT_ONCE_FN;
1719const LARGE_INTEGER = windows.LARGE_INTEGER;
20const LPCSTR = windows.LPCSTR;
21const LPCVOID = windows.LPCVOID;
1822const LPCWSTR = windows.LPCWSTR;
1923const LPTHREAD_START_ROUTINE = windows.LPTHREAD_START_ROUTINE;
2024const LPVOID = windows.LPVOID;
2125const LPWSTR = windows.LPWSTR;
22const MODULEINFO = windows.MODULEINFO;
26const MODULEENTRY32 = windows.MODULEENTRY32;
2327const OVERLAPPED = windows.OVERLAPPED;
24const PERFORMANCE_INFORMATION = windows.PERFORMANCE_INFORMATION;
25const PROCESS_MEMORY_COUNTERS = windows.PROCESS_MEMORY_COUNTERS;
26const PSAPI_WS_WATCH_INFORMATION = windows.PSAPI_WS_WATCH_INFORMATION;
27const PSAPI_WS_WATCH_INFORMATION_EX = windows.PSAPI_WS_WATCH_INFORMATION_EX;
28const OVERLAPPED_ENTRY = windows.OVERLAPPED_ENTRY;
29const PMEMORY_BASIC_INFORMATION = windows.PMEMORY_BASIC_INFORMATION;
30const PROCESS_INFORMATION = windows.PROCESS_INFORMATION;
2831const SECURITY_ATTRIBUTES = windows.SECURITY_ATTRIBUTES;
2932const SIZE_T = windows.SIZE_T;
3033const SRWLOCK = windows.SRWLOCK;
34const STARTUPINFOW = windows.STARTUPINFOW;
35const UCHAR = windows.UCHAR;
3136const UINT = windows.UINT;
37const ULONG = windows.ULONG;
38const ULONG_PTR = windows.ULONG_PTR;
39const va_list = windows.va_list;
3240const VECTORED_EXCEPTION_HANDLER = windows.VECTORED_EXCEPTION_HANDLER;
3341const WCHAR = windows.WCHAR;
42const WIN32_FIND_DATAW = windows.WIN32_FIND_DATAW;
43const Win32Error = windows.Win32Error;
3444const WINAPI = windows.WINAPI;
3545const WORD = windows.WORD;
36const Win32Error = windows.Win32Error;
37const va_list = windows.va_list;
38const HLOCAL = windows.HLOCAL;
39const FILETIME = windows.FILETIME;
40const STARTUPINFOW = windows.STARTUPINFOW;
41const PROCESS_INFORMATION = windows.PROCESS_INFORMATION;
42const OVERLAPPED_ENTRY = windows.OVERLAPPED_ENTRY;
43const LPHEAP_SUMMARY = windows.LPHEAP_SUMMARY;
44const ULONG_PTR = windows.ULONG_PTR;
45const FILE_NOTIFY_INFORMATION = windows.FILE_NOTIFY_INFORMATION;
46const HANDLER_ROUTINE = windows.HANDLER_ROUTINE;
47const ULONG = windows.ULONG;
48const PVOID = windows.PVOID;
49const LPSTR = windows.LPSTR;
50const PENUM_PAGE_FILE_CALLBACKA = windows.PENUM_PAGE_FILE_CALLBACKA;
51const PENUM_PAGE_FILE_CALLBACKW = windows.PENUM_PAGE_FILE_CALLBACKW;
52const INIT_ONCE = windows.INIT_ONCE;
53const CRITICAL_SECTION = windows.CRITICAL_SECTION;
54const WIN32_FIND_DATAW = windows.WIN32_FIND_DATAW;
55const CHAR = windows.CHAR;
56const BY_HANDLE_FILE_INFORMATION = windows.BY_HANDLE_FILE_INFORMATION;
57const SYSTEM_INFO = windows.SYSTEM_INFO;
58const LPOVERLAPPED_COMPLETION_ROUTINE = windows.LPOVERLAPPED_COMPLETION_ROUTINE;
59const UCHAR = windows.UCHAR;
60const FARPROC = windows.FARPROC;
61const INIT_ONCE_FN = windows.INIT_ONCE_FN;
62const PMEMORY_BASIC_INFORMATION = windows.PMEMORY_BASIC_INFORMATION;
63const REGSAM = windows.REGSAM;
64const LSTATUS = windows.LSTATUS;
65const UNWIND_HISTORY_TABLE = windows.UNWIND_HISTORY_TABLE;
66const RUNTIME_FUNCTION = windows.RUNTIME_FUNCTION;
67const KNONVOLATILE_CONTEXT_POINTERS = windows.KNONVOLATILE_CONTEXT_POINTERS;
68const EXCEPTION_ROUTINE = windows.EXCEPTION_ROUTINE;
69const MODULEENTRY32 = windows.MODULEENTRY32;
70const ULONGLONG = windows.ULONGLONG;
71
72pub extern "kernel32" fn AddVectoredExceptionHandler(First: c_ulong, Handler: ?VECTORED_EXCEPTION_HANDLER) callconv(WINAPI) ?*anyopaque;
73pub extern "kernel32" fn RemoveVectoredExceptionHandler(Handle: HANDLE) callconv(WINAPI) c_ulong;
74
75pub extern "kernel32" fn CancelIo(hFile: HANDLE) callconv(WINAPI) BOOL;
76pub extern "kernel32" fn CancelIoEx(hFile: HANDLE, lpOverlapped: ?*OVERLAPPED) callconv(WINAPI) BOOL;
7746
78pub extern "kernel32" fn CloseHandle(hObject: HANDLE) callconv(WINAPI) BOOL;
79
80pub extern "kernel32" fn CreateDirectoryW(lpPathName: [*:0]const u16, lpSecurityAttributes: ?*SECURITY_ATTRIBUTES) callconv(WINAPI) BOOL;
81pub extern "kernel32" fn SetEndOfFile(hFile: HANDLE) callconv(WINAPI) BOOL;
47// I/O - Filesystem
48// TODO: Wrapper around NtCancelIoFile.
49pub extern "kernel32" fn CancelIo(
50 hFile: HANDLE,
51) callconv(WINAPI) BOOL;
8252
83pub extern "kernel32" fn CreateEventExW(
84 lpEventAttributes: ?*SECURITY_ATTRIBUTES,
85 lpName: ?LPCWSTR,
86 dwFlags: DWORD,
87 dwDesiredAccess: DWORD,
88) callconv(WINAPI) ?HANDLE;
53// TODO: Wrapper around NtCancelIoFileEx.
54pub extern "kernel32" fn CancelIoEx(
55 hFile: HANDLE,
56 lpOverlapped: ?*OVERLAPPED,
57) callconv(WINAPI) BOOL;
8958
9059pub extern "kernel32" fn CreateFileW(
91 lpFileName: [*:0]const u16,
60 lpFileName: LPCWSTR,
9261 dwDesiredAccess: DWORD,
9362 dwShareMode: DWORD,
9463 lpSecurityAttributes: ?*SECURITY_ATTRIBUTES,
......@@ -97,13 +66,7 @@ pub extern "kernel32" fn CreateFileW(
9766 hTemplateFile: ?HANDLE,
9867) callconv(WINAPI) HANDLE;
9968
100pub extern "kernel32" fn CreatePipe(
101 hReadPipe: *HANDLE,
102 hWritePipe: *HANDLE,
103 lpPipeAttributes: *const SECURITY_ATTRIBUTES,
104 nSize: DWORD,
105) callconv(WINAPI) BOOL;
106
69// TODO A bunch of logic around NtCreateNamedPipe
10770pub extern "kernel32" fn CreateNamedPipeW(
10871 lpName: LPCWSTR,
10972 dwOpenMode: DWORD,
......@@ -115,349 +78,584 @@ pub extern "kernel32" fn CreateNamedPipeW(
11578 lpSecurityAttributes: ?*const SECURITY_ATTRIBUTES,
11679) callconv(WINAPI) HANDLE;
11780
118pub extern "kernel32" fn CreateProcessW(
119 lpApplicationName: ?LPCWSTR,
120 lpCommandLine: ?LPWSTR,
121 lpProcessAttributes: ?*SECURITY_ATTRIBUTES,
122 lpThreadAttributes: ?*SECURITY_ATTRIBUTES,
123 bInheritHandles: BOOL,
124 dwCreationFlags: DWORD,
125 lpEnvironment: ?*anyopaque,
126 lpCurrentDirectory: ?LPCWSTR,
127 lpStartupInfo: *STARTUPINFOW,
128 lpProcessInformation: *PROCESS_INFORMATION,
81pub extern "kernel32" fn FindFirstFileW(
82 lpFileName: LPCWSTR,
83 lpFindFileData: *WIN32_FIND_DATAW,
84) callconv(WINAPI) HANDLE;
85
86pub extern "kernel32" fn FindClose(
87 hFindFile: HANDLE,
12988) callconv(WINAPI) BOOL;
13089
131pub extern "kernel32" fn CreateSymbolicLinkW(lpSymlinkFileName: [*:0]const u16, lpTargetFileName: [*:0]const u16, dwFlags: DWORD) callconv(WINAPI) BOOLEAN;
90// TODO: Wrapper around RtlGetFullPathName_UEx
91pub extern "kernel32" fn GetFullPathNameW(
92 lpFileName: LPCWSTR,
93 nBufferLength: DWORD,
94 lpBuffer: LPWSTR,
95 lpFilePart: ?*?LPWSTR,
96) callconv(WINAPI) DWORD;
13297
133pub extern "kernel32" fn CreateIoCompletionPort(FileHandle: HANDLE, ExistingCompletionPort: ?HANDLE, CompletionKey: ULONG_PTR, NumberOfConcurrentThreads: DWORD) callconv(WINAPI) ?HANDLE;
98// TODO: Matches `STD_*_HANDLE` to peb().ProcessParameters.Standard*
99pub extern "kernel32" fn GetStdHandle(
100 nStdHandle: DWORD,
101) callconv(WINAPI) ?HANDLE;
134102
135pub extern "kernel32" fn CreateThread(lpThreadAttributes: ?*SECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: ?LPVOID, dwCreationFlags: DWORD, lpThreadId: ?*DWORD) callconv(WINAPI) ?HANDLE;
103pub extern "kernel32" fn MoveFileExW(
104 lpExistingFileName: LPCWSTR,
105 lpNewFileName: LPCWSTR,
106 dwFlags: DWORD,
107) callconv(WINAPI) BOOL;
136108
137pub extern "kernel32" fn CreateToolhelp32Snapshot(dwFlags: DWORD, th32ProcessID: DWORD) callconv(WINAPI) HANDLE;
109// TODO: Wrapper around NtSetInformationFile + `FILE_POSITION_INFORMATION`.
110// `FILE_STANDARD_INFORMATION` is also used if dwMoveMethod is `FILE_END`
111pub extern "kernel32" fn SetFilePointerEx(
112 hFile: HANDLE,
113 liDistanceToMove: LARGE_INTEGER,
114 lpNewFilePointer: ?*LARGE_INTEGER,
115 dwMoveMethod: DWORD,
116) callconv(WINAPI) BOOL;
138117
139pub extern "kernel32" fn DeviceIoControl(
140 h: HANDLE,
141 dwIoControlCode: DWORD,
142 lpInBuffer: ?*const anyopaque,
143 nInBufferSize: DWORD,
144 lpOutBuffer: ?LPVOID,
145 nOutBufferSize: DWORD,
146 lpBytesReturned: ?*DWORD,
147 lpOverlapped: ?*OVERLAPPED,
118// TODO: Wrapper around NtSetInformationFile + `FILE_BASIC_INFORMATION`
119pub extern "kernel32" fn SetFileTime(
120 hFile: HANDLE,
121 lpCreationTime: ?*const FILETIME,
122 lpLastAccessTime: ?*const FILETIME,
123 lpLastWriteTime: ?*const FILETIME,
148124) callconv(WINAPI) BOOL;
149125
150pub extern "kernel32" fn DeleteFileW(lpFileName: [*:0]const u16) callconv(WINAPI) BOOL;
126pub extern "kernel32" fn WriteFile(
127 in_hFile: HANDLE,
128 in_lpBuffer: [*]const u8,
129 in_nNumberOfBytesToWrite: DWORD,
130 out_lpNumberOfBytesWritten: ?*DWORD,
131 in_out_lpOverlapped: ?*OVERLAPPED,
132) callconv(WINAPI) BOOL;
151133
152pub extern "kernel32" fn DuplicateHandle(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: *HANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD) callconv(WINAPI) BOOL;
134// TODO: wrapper for NtQueryInformationFile + `FILE_STANDARD_INFORMATION`
135pub extern "kernel32" fn GetFileSizeEx(
136 hFile: HANDLE,
137 lpFileSize: *LARGE_INTEGER,
138) callconv(WINAPI) BOOL;
153139
154pub extern "kernel32" fn ExitProcess(exit_code: UINT) callconv(WINAPI) noreturn;
140// TODO: Wrapper around GetStdHandle + NtFlushBuffersFile.
141pub extern "kernel32" fn FlushFileBuffers(
142 hFile: HANDLE,
143) callconv(WINAPI) BOOL;
155144
156pub extern "kernel32" fn FindFirstFileW(lpFileName: [*:0]const u16, lpFindFileData: *WIN32_FIND_DATAW) callconv(WINAPI) HANDLE;
157pub extern "kernel32" fn FindClose(hFindFile: HANDLE) callconv(WINAPI) BOOL;
158pub extern "kernel32" fn FindNextFileW(hFindFile: HANDLE, lpFindFileData: *WIN32_FIND_DATAW) callconv(WINAPI) BOOL;
145// TODO: Wrapper around NtSetInformationFile + `FILE_IO_COMPLETION_NOTIFICATION_INFORMATION`.
146pub extern "kernel32" fn SetFileCompletionNotificationModes(
147 FileHandle: HANDLE,
148 Flags: UCHAR,
149) callconv(WINAPI) BOOL;
159150
160pub extern "kernel32" fn FormatMessageW(dwFlags: DWORD, lpSource: ?LPVOID, dwMessageId: Win32Error, dwLanguageId: DWORD, lpBuffer: [*]u16, nSize: DWORD, Arguments: ?*va_list) callconv(WINAPI) DWORD;
151// TODO: `RtlGetCurrentDirectory_U(nBufferLength * 2, lpBuffer)`
152pub extern "kernel32" fn GetCurrentDirectoryW(
153 nBufferLength: DWORD,
154 lpBuffer: ?[*]WCHAR,
155) callconv(WINAPI) DWORD;
161156
162pub extern "kernel32" fn FreeEnvironmentStringsW(penv: [*:0]u16) callconv(WINAPI) BOOL;
157// TODO: RtlDosPathNameToNtPathNameU_WithStatus + NtQueryAttributesFile.
158pub extern "kernel32" fn GetFileAttributesW(
159 lpFileName: LPCWSTR,
160) callconv(WINAPI) DWORD;
163161
164pub extern "kernel32" fn GetConsoleMode(in_hConsoleHandle: HANDLE, out_lpMode: *DWORD) callconv(WINAPI) BOOL;
165pub extern "kernel32" fn SetConsoleMode(in_hConsoleHandle: HANDLE, in_dwMode: DWORD) callconv(WINAPI) BOOL;
162pub extern "kernel32" fn ReadFile(
163 hFile: HANDLE,
164 lpBuffer: LPVOID,
165 nNumberOfBytesToRead: DWORD,
166 lpNumberOfBytesRead: ?*DWORD,
167 lpOverlapped: ?*OVERLAPPED,
168) callconv(WINAPI) BOOL;
166169
167pub extern "kernel32" fn GetConsoleOutputCP() callconv(WINAPI) UINT;
170pub extern "kernel32" fn GetSystemDirectoryW(
171 lpBuffer: LPWSTR,
172 uSize: UINT,
173) callconv(WINAPI) UINT;
168174
169pub extern "kernel32" fn GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: *CONSOLE_SCREEN_BUFFER_INFO) callconv(WINAPI) BOOL;
170pub extern "kernel32" fn FillConsoleOutputCharacterA(hConsoleOutput: HANDLE, cCharacter: CHAR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: *DWORD) callconv(WINAPI) BOOL;
171pub extern "kernel32" fn FillConsoleOutputCharacterW(hConsoleOutput: HANDLE, cCharacter: WCHAR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: *DWORD) callconv(WINAPI) BOOL;
172pub extern "kernel32" fn FillConsoleOutputAttribute(hConsoleOutput: HANDLE, wAttribute: WORD, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfAttrsWritten: *DWORD) callconv(WINAPI) BOOL;
173pub extern "kernel32" fn SetConsoleCursorPosition(hConsoleOutput: HANDLE, dwCursorPosition: COORD) callconv(WINAPI) BOOL;
175// I/O - Kernel Objects
174176
175pub extern "kernel32" fn WriteConsoleW(hConsoleOutput: HANDLE, lpBuffer: [*]const u16, nNumberOfCharsToWrite: DWORD, lpNumberOfCharsWritten: ?*DWORD, lpReserved: ?LPVOID) callconv(WINAPI) BOOL;
176pub extern "kernel32" fn ReadConsoleOutputCharacterW(
177 hConsoleOutput: windows.HANDLE,
178 lpCharacter: [*]u16,
179 nLength: windows.DWORD,
180 dwReadCoord: windows.COORD,
181 lpNumberOfCharsRead: *windows.DWORD,
182) callconv(windows.WINAPI) windows.BOOL;
177// TODO: Wrapper around NtCreateEvent.
178pub extern "kernel32" fn CreateEventExW(
179 lpEventAttributes: ?*SECURITY_ATTRIBUTES,
180 lpName: ?LPCWSTR,
181 dwFlags: DWORD,
182 dwDesiredAccess: DWORD,
183) callconv(WINAPI) ?HANDLE;
183184
184pub extern "kernel32" fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: ?[*]WCHAR) callconv(WINAPI) DWORD;
185// TODO: Wrapper around GetStdHandle + NtDuplicateObject.
186pub extern "kernel32" fn DuplicateHandle(
187 hSourceProcessHandle: HANDLE,
188 hSourceHandle: HANDLE,
189 hTargetProcessHandle: HANDLE,
190 lpTargetHandle: *HANDLE,
191 dwDesiredAccess: DWORD,
192 bInheritHandle: BOOL,
193 dwOptions: DWORD,
194) callconv(WINAPI) BOOL;
185195
186pub extern "kernel32" fn GetCurrentThread() callconv(WINAPI) HANDLE;
187pub extern "kernel32" fn GetCurrentThreadId() callconv(WINAPI) DWORD;
196// TODO: Wrapper around GetStdHandle + NtQueryObject + NtSetInformationObject with .ObjectHandleFlagInformation.
197pub extern "kernel32" fn SetHandleInformation(
198 hObject: HANDLE,
199 dwMask: DWORD,
200 dwFlags: DWORD,
201) callconv(WINAPI) BOOL;
188202
189pub extern "kernel32" fn GetCurrentProcessId() callconv(WINAPI) DWORD;
203// TODO: Wrapper around NtRemoveIoCompletion.
204pub extern "kernel32" fn GetQueuedCompletionStatus(
205 CompletionPort: HANDLE,
206 lpNumberOfBytesTransferred: *DWORD,
207 lpCompletionKey: *ULONG_PTR,
208 lpOverlapped: *?*OVERLAPPED,
209 dwMilliseconds: DWORD,
210) callconv(WINAPI) BOOL;
190211
191pub extern "kernel32" fn GetCurrentProcess() callconv(WINAPI) HANDLE;
212// TODO: Wrapper around NtRemoveIoCompletionEx.
213pub extern "kernel32" fn GetQueuedCompletionStatusEx(
214 CompletionPort: HANDLE,
215 lpCompletionPortEntries: [*]OVERLAPPED_ENTRY,
216 ulCount: ULONG,
217 ulNumEntriesRemoved: *ULONG,
218 dwMilliseconds: DWORD,
219 fAlertable: BOOL,
220) callconv(WINAPI) BOOL;
192221
193pub extern "kernel32" fn GetEnvironmentStringsW() callconv(WINAPI) ?[*:0]u16;
222// TODO: Wrapper around NtSetIoCompletion with `IoStatus = .SUCCESS`.
223pub extern "kernel32" fn PostQueuedCompletionStatus(
224 CompletionPort: HANDLE,
225 dwNumberOfBytesTransferred: DWORD,
226 dwCompletionKey: ULONG_PTR,
227 lpOverlapped: ?*OVERLAPPED,
228) callconv(WINAPI) BOOL;
194229
195pub extern "kernel32" fn GetEnvironmentVariableW(lpName: LPWSTR, lpBuffer: [*]u16, nSize: DWORD) callconv(WINAPI) DWORD;
230// TODO:
231// GetOverlappedResultEx with bAlertable=false, which calls: GetStdHandle + WaitForSingleObjectEx.
232// Uses the SwitchBack system to run implementations for older programs; Do we care about this?
233pub extern "kernel32" fn GetOverlappedResult(
234 hFile: HANDLE,
235 lpOverlapped: *OVERLAPPED,
236 lpNumberOfBytesTransferred: *DWORD,
237 bWait: BOOL,
238) callconv(WINAPI) BOOL;
196239
197pub extern "kernel32" fn SetEnvironmentVariableW(lpName: LPCWSTR, lpValue: ?LPCWSTR) callconv(WINAPI) BOOL;
240// TODO: Wrapper around NtCreateIoCompletion + NtSetInformationFile with FILE_COMPLETION_INFORMATION.
241// This would be better splitting into two functions.
242pub extern "kernel32" fn CreateIoCompletionPort(
243 FileHandle: HANDLE,
244 ExistingCompletionPort: ?HANDLE,
245 CompletionKey: ULONG_PTR,
246 NumberOfConcurrentThreads: DWORD,
247) callconv(WINAPI) ?HANDLE;
198248
199pub extern "kernel32" fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: *DWORD) callconv(WINAPI) BOOL;
249// TODO: Forwarder to NtAddVectoredExceptionHandler.
250pub extern "kernel32" fn AddVectoredExceptionHandler(
251 First: ULONG,
252 Handler: ?VECTORED_EXCEPTION_HANDLER,
253) callconv(WINAPI) ?LPVOID;
254
255// TODO: Forwarder to NtRemoveVectoredExceptionHandler.
256pub extern "kernel32" fn RemoveVectoredExceptionHandler(
257 Handle: HANDLE,
258) callconv(WINAPI) ULONG;
259
260// TODO: Wrapper around RtlReportSilentProcessExit + NtTerminateProcess.
261pub extern "kernel32" fn TerminateProcess(
262 hProcess: HANDLE,
263 uExitCode: UINT,
264) callconv(WINAPI) BOOL;
200265
201pub extern "kernel32" fn GetFileSizeEx(hFile: HANDLE, lpFileSize: *LARGE_INTEGER) callconv(WINAPI) BOOL;
266// TODO: WaitForSingleObjectEx with bAlertable=false.
267pub extern "kernel32" fn WaitForSingleObject(
268 hHandle: HANDLE,
269 dwMilliseconds: DWORD,
270) callconv(WINAPI) DWORD;
202271
203pub extern "kernel32" fn GetFileAttributesW(lpFileName: [*:0]const WCHAR) callconv(WINAPI) DWORD;
272// TODO: Wrapper for GetStdHandle + NtWaitForSingleObject.
273// Sets up an activation context before calling NtWaitForSingleObject.
274pub extern "kernel32" fn WaitForSingleObjectEx(
275 hHandle: HANDLE,
276 dwMilliseconds: DWORD,
277 bAlertable: BOOL,
278) callconv(WINAPI) DWORD;
204279
205pub extern "kernel32" fn GetModuleFileNameW(hModule: ?HMODULE, lpFilename: [*]u16, nSize: DWORD) callconv(WINAPI) DWORD;
280// TODO: WaitForMultipleObjectsEx with alertable=false
281pub extern "kernel32" fn WaitForMultipleObjects(
282 nCount: DWORD,
283 lpHandle: [*]const HANDLE,
284 bWaitAll: BOOL,
285 dwMilliseconds: DWORD,
286) callconv(WINAPI) DWORD;
206287
207pub extern "kernel32" fn GetModuleHandleW(lpModuleName: ?[*:0]const WCHAR) callconv(WINAPI) ?HMODULE;
288// TODO: Wrapper around NtWaitForMultipleObjects.
289pub extern "kernel32" fn WaitForMultipleObjectsEx(
290 nCount: DWORD,
291 lpHandle: [*]const HANDLE,
292 bWaitAll: BOOL,
293 dwMilliseconds: DWORD,
294 bAlertable: BOOL,
295) callconv(WINAPI) DWORD;
208296
209pub extern "kernel32" fn GetLastError() callconv(WINAPI) Win32Error;
210pub extern "kernel32" fn SetLastError(dwErrCode: Win32Error) callconv(WINAPI) void;
297// Process Management
211298
212pub extern "kernel32" fn GetFileInformationByHandleEx(
213 in_hFile: HANDLE,
214 in_FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
215 out_lpFileInformation: *anyopaque,
216 in_dwBufferSize: DWORD,
299pub extern "kernel32" fn CreateProcessW(
300 lpApplicationName: ?LPCWSTR,
301 lpCommandLine: ?LPWSTR,
302 lpProcessAttributes: ?*SECURITY_ATTRIBUTES,
303 lpThreadAttributes: ?*SECURITY_ATTRIBUTES,
304 bInheritHandles: BOOL,
305 dwCreationFlags: DWORD,
306 lpEnvironment: ?LPVOID,
307 lpCurrentDirectory: ?LPCWSTR,
308 lpStartupInfo: *STARTUPINFOW,
309 lpProcessInformation: *PROCESS_INFORMATION,
217310) callconv(WINAPI) BOOL;
218311
219pub extern "kernel32" fn GetFinalPathNameByHandleW(
220 hFile: HANDLE,
221 lpszFilePath: [*]u16,
222 cchFilePath: DWORD,
223 dwFlags: DWORD,
224) callconv(WINAPI) DWORD;
312// TODO: Fowarder to RtlExitUserProcess.
313pub extern "kernel32" fn ExitProcess(
314 exit_code: UINT,
315) callconv(WINAPI) noreturn;
225316
226pub extern "kernel32" fn GetFullPathNameW(
227 lpFileName: [*:0]const u16,
228 nBufferLength: u32,
229 lpBuffer: [*]u16,
230 lpFilePart: ?*?[*:0]u16,
231) callconv(@import("std").os.windows.WINAPI) u32;
317// TODO: SleepEx with bAlertable=false.
318pub extern "kernel32" fn Sleep(
319 dwMilliseconds: DWORD,
320) callconv(WINAPI) void;
232321
233pub extern "kernel32" fn GetOverlappedResult(hFile: HANDLE, lpOverlapped: *OVERLAPPED, lpNumberOfBytesTransferred: *DWORD, bWait: BOOL) callconv(WINAPI) BOOL;
322// TODO: Wrapper around NtQueryInformationProcess with `PROCESS_BASIC_INFORMATION`.
323pub extern "kernel32" fn GetExitCodeProcess(
324 hProcess: HANDLE,
325 lpExitCode: *DWORD,
326) callconv(WINAPI) BOOL;
234327
235pub extern "kernel32" fn GetProcessHeap() callconv(WINAPI) ?HANDLE;
328// TODO: Already a wrapper for this, see `windows.GetCurrentProcess`.
329pub extern "kernel32" fn GetCurrentProcess() callconv(WINAPI) HANDLE;
236330
237pub extern "kernel32" fn GetProcessTimes(in_hProcess: HANDLE, out_lpCreationTime: *FILETIME, out_lpExitTime: *FILETIME, out_lpKernelTime: *FILETIME, out_lpUserTime: *FILETIME) callconv(WINAPI) BOOL;
331// TODO: memcpy peb().ProcessParameters.Environment, mem.span(0). Requires locking the PEB.
332pub extern "kernel32" fn GetEnvironmentStringsW() callconv(WINAPI) ?LPWSTR;
238333
239pub extern "kernel32" fn GetQueuedCompletionStatus(CompletionPort: HANDLE, lpNumberOfBytesTransferred: *DWORD, lpCompletionKey: *ULONG_PTR, lpOverlapped: *?*OVERLAPPED, dwMilliseconds: DWORD) callconv(WINAPI) BOOL;
240pub extern "kernel32" fn GetQueuedCompletionStatusEx(
241 CompletionPort: HANDLE,
242 lpCompletionPortEntries: [*]OVERLAPPED_ENTRY,
243 ulCount: ULONG,
244 ulNumEntriesRemoved: *ULONG,
245 dwMilliseconds: DWORD,
246 fAlertable: BOOL,
334// TODO: RtlFreeHeap on the output of GetEnvironmentStringsW.
335pub extern "kernel32" fn FreeEnvironmentStringsW(
336 penv: LPWSTR,
247337) callconv(WINAPI) BOOL;
248338
249pub extern "kernel32" fn GetSystemInfo(lpSystemInfo: *SYSTEM_INFO) callconv(WINAPI) void;
250pub extern "kernel32" fn GetSystemTimeAsFileTime(*FILETIME) callconv(WINAPI) void;
251pub extern "kernel32" fn IsProcessorFeaturePresent(ProcessorFeature: DWORD) BOOL;
252
253pub extern "kernel32" fn GetSystemDirectoryW(lpBuffer: LPWSTR, uSize: UINT) callconv(WINAPI) UINT;
339// TODO: Wrapper around RtlQueryEnvironmentVariable.
340pub extern "kernel32" fn GetEnvironmentVariableW(
341 lpName: ?LPCWSTR,
342 lpBuffer: ?[*]WCHAR,
343 nSize: DWORD,
344) callconv(WINAPI) DWORD;
254345
255pub extern "kernel32" fn HeapCreate(flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T) callconv(WINAPI) ?HANDLE;
256pub extern "kernel32" fn HeapDestroy(hHeap: HANDLE) callconv(WINAPI) BOOL;
257pub extern "kernel32" fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: *anyopaque, dwBytes: SIZE_T) callconv(WINAPI) ?*anyopaque;
258pub extern "kernel32" fn HeapSize(hHeap: HANDLE, dwFlags: DWORD, lpMem: *const anyopaque) callconv(WINAPI) SIZE_T;
259pub extern "kernel32" fn HeapCompact(hHeap: HANDLE, dwFlags: DWORD) callconv(WINAPI) SIZE_T;
260pub extern "kernel32" fn HeapSummary(hHeap: HANDLE, dwFlags: DWORD, lpSummary: LPHEAP_SUMMARY) callconv(WINAPI) BOOL;
346// TODO: Wrapper around RtlSetEnvironmentVar.
347pub extern "kernel32" fn SetEnvironmentVariableW(
348 lpName: LPCWSTR,
349 lpValue: ?LPCWSTR,
350) callconv(WINAPI) BOOL;
261351
262pub extern "kernel32" fn GetStdHandle(in_nStdHandle: DWORD) callconv(WINAPI) ?HANDLE;
352pub extern "kernel32" fn CreateToolhelp32Snapshot(
353 dwFlags: DWORD,
354 th32ProcessID: DWORD,
355) callconv(WINAPI) HANDLE;
263356
264pub extern "kernel32" fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) callconv(WINAPI) ?*anyopaque;
357// Threading
265358
266pub extern "kernel32" fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: *anyopaque) callconv(WINAPI) BOOL;
359// TODO: Already a wrapper for this, see `windows.GetCurrentThreadId`.
360pub extern "kernel32" fn GetCurrentThreadId() callconv(WINAPI) DWORD;
267361
268pub extern "kernel32" fn HeapValidate(hHeap: HANDLE, dwFlags: DWORD, lpMem: ?*const anyopaque) callconv(WINAPI) BOOL;
362// TODO: CreateRemoteThread with hProcess=NtCurrentProcess().
363pub extern "kernel32" fn CreateThread(
364 lpThreadAttributes: ?*SECURITY_ATTRIBUTES,
365 dwStackSize: SIZE_T,
366 lpStartAddress: LPTHREAD_START_ROUTINE,
367 lpParameter: ?LPVOID,
368 dwCreationFlags: DWORD,
369 lpThreadId: ?*DWORD,
370) callconv(WINAPI) ?HANDLE;
269371
270pub extern "kernel32" fn VirtualAlloc(lpAddress: ?LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) callconv(WINAPI) ?LPVOID;
271pub extern "kernel32" fn VirtualFree(lpAddress: ?LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) callconv(WINAPI) BOOL;
272pub extern "kernel32" fn VirtualQuery(lpAddress: ?LPVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T) callconv(WINAPI) SIZE_T;
372// TODO: Wrapper around RtlDelayExecution.
373pub extern "kernel32" fn SwitchToThread() callconv(WINAPI) BOOL;
273374
274pub extern "kernel32" fn LocalFree(hMem: HLOCAL) callconv(WINAPI) ?HLOCAL;
375// Locks, critical sections, initializers
376
377// TODO: Forwarder to RtlInitializeCriticalSection
378pub extern "kernel32" fn InitializeCriticalSection(
379 lpCriticalSection: *CRITICAL_SECTION,
380) callconv(WINAPI) void;
381
382// TODO: Forwarder to RtlEnterCriticalSection
383pub extern "kernel32" fn EnterCriticalSection(
384 lpCriticalSection: *CRITICAL_SECTION,
385) callconv(WINAPI) void;
386
387// TODO: Forwarder to RtlLeaveCriticalSection
388pub extern "kernel32" fn LeaveCriticalSection(
389 lpCriticalSection: *CRITICAL_SECTION,
390) callconv(WINAPI) void;
391
392// TODO: Forwarder to RtlDeleteCriticalSection
393pub extern "kernel32" fn DeleteCriticalSection(
394 lpCriticalSection: *CRITICAL_SECTION,
395) callconv(WINAPI) void;
396
397// TODO: Forwarder to RtlTryAcquireSRWLockExclusive
398pub extern "kernel32" fn TryAcquireSRWLockExclusive(
399 SRWLock: *SRWLOCK,
400) callconv(WINAPI) BOOLEAN;
401
402// TODO: Forwarder to RtlAcquireSRWLockExclusive
403pub extern "kernel32" fn AcquireSRWLockExclusive(
404 SRWLock: *SRWLOCK,
405) callconv(WINAPI) void;
406
407// TODO: Forwarder to RtlReleaseSRWLockExclusive
408pub extern "kernel32" fn ReleaseSRWLockExclusive(
409 SRWLock: *SRWLOCK,
410) callconv(WINAPI) void;
411
412pub extern "kernel32" fn InitOnceExecuteOnce(
413 InitOnce: *INIT_ONCE,
414 InitFn: INIT_ONCE_FN,
415 Parameter: ?*anyopaque,
416 Context: ?*anyopaque,
417) callconv(WINAPI) BOOL;
275418
276pub extern "kernel32" fn Module32First(hSnapshot: HANDLE, lpme: *MODULEENTRY32) callconv(WINAPI) BOOL;
419// TODO: Forwarder to RtlWakeConditionVariable
420pub extern "kernel32" fn WakeConditionVariable(
421 ConditionVariable: *CONDITION_VARIABLE,
422) callconv(WINAPI) void;
277423
278pub extern "kernel32" fn Module32Next(hSnapshot: HANDLE, lpme: *MODULEENTRY32) callconv(WINAPI) BOOL;
424// TODO: Forwarder to RtlWakeAllConditionVariable
425pub extern "kernel32" fn WakeAllConditionVariable(
426 ConditionVariable: *CONDITION_VARIABLE,
427) callconv(WINAPI) void;
279428
280pub extern "kernel32" fn MoveFileExW(
281 lpExistingFileName: [*:0]const u16,
282 lpNewFileName: [*:0]const u16,
283 dwFlags: DWORD,
429// TODO:
430// - dwMilliseconds -> LARGE_INTEGER.
431// - RtlSleepConditionVariableSRW
432// - return rc != .TIMEOUT
433pub extern "kernel32" fn SleepConditionVariableSRW(
434 ConditionVariable: *CONDITION_VARIABLE,
435 SRWLock: *SRWLOCK,
436 dwMilliseconds: DWORD,
437 Flags: ULONG,
284438) callconv(WINAPI) BOOL;
285439
286pub extern "kernel32" fn PostQueuedCompletionStatus(CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: ULONG_PTR, lpOverlapped: ?*OVERLAPPED) callconv(WINAPI) BOOL;
440// Console management
287441
288pub extern "kernel32" fn ReadDirectoryChangesW(
289 hDirectory: HANDLE,
290 lpBuffer: [*]align(@alignOf(FILE_NOTIFY_INFORMATION)) u8,
291 nBufferLength: DWORD,
292 bWatchSubtree: BOOL,
293 dwNotifyFilter: DWORD,
294 lpBytesReturned: ?*DWORD,
295 lpOverlapped: ?*OVERLAPPED,
296 lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
442pub extern "kernel32" fn GetConsoleMode(
443 hConsoleHandle: HANDLE,
444 lpMode: *DWORD,
297445) callconv(WINAPI) BOOL;
298446
299pub extern "kernel32" fn ReadFile(
300 in_hFile: HANDLE,
301 out_lpBuffer: [*]u8,
302 in_nNumberOfBytesToRead: DWORD,
303 out_lpNumberOfBytesRead: ?*DWORD,
304 in_out_lpOverlapped: ?*OVERLAPPED,
447pub extern "kernel32" fn SetConsoleMode(
448 hConsoleHandle: HANDLE,
449 dwMode: DWORD,
305450) callconv(WINAPI) BOOL;
306451
307pub extern "kernel32" fn RemoveDirectoryW(lpPathName: [*:0]const u16) callconv(WINAPI) BOOL;
308
309pub extern "kernel32" fn RtlCaptureContext(ContextRecord: *CONTEXT) callconv(WINAPI) void;
310
311pub extern "kernel32" fn RtlLookupFunctionEntry(
312 ControlPc: DWORD64,
313 ImageBase: *DWORD64,
314 HistoryTable: *UNWIND_HISTORY_TABLE,
315) callconv(WINAPI) ?*RUNTIME_FUNCTION;
316
317pub extern "kernel32" fn RtlVirtualUnwind(
318 HandlerType: DWORD,
319 ImageBase: DWORD64,
320 ControlPc: DWORD64,
321 FunctionEntry: *RUNTIME_FUNCTION,
322 ContextRecord: *CONTEXT,
323 HandlerData: *?PVOID,
324 EstablisherFrame: *DWORD64,
325 ContextPointers: ?*KNONVOLATILE_CONTEXT_POINTERS,
326) callconv(WINAPI) *EXCEPTION_ROUTINE;
452pub extern "kernel32" fn GetConsoleScreenBufferInfo(
453 hConsoleOutput: HANDLE,
454 lpConsoleScreenBufferInfo: *CONSOLE_SCREEN_BUFFER_INFO,
455) callconv(WINAPI) BOOL;
327456
328pub extern "kernel32" fn SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) callconv(WINAPI) BOOL;
457pub extern "kernel32" fn SetConsoleTextAttribute(
458 hConsoleOutput: HANDLE,
459 wAttributes: WORD,
460) callconv(WINAPI) BOOL;
329461
330462pub extern "kernel32" fn SetConsoleCtrlHandler(
331463 HandlerRoutine: ?HANDLER_ROUTINE,
332464 Add: BOOL,
333465) callconv(WINAPI) BOOL;
334466
335pub extern "kernel32" fn SetConsoleOutputCP(wCodePageID: UINT) callconv(WINAPI) BOOL;
467pub extern "kernel32" fn SetConsoleOutputCP(
468 wCodePageID: UINT,
469) callconv(WINAPI) BOOL;
336470
337pub extern "kernel32" fn SetFileCompletionNotificationModes(
338 FileHandle: HANDLE,
339 Flags: UCHAR,
471pub extern "kernel32" fn GetConsoleOutputCP() callconv(WINAPI) UINT;
472
473pub extern "kernel32" fn FillConsoleOutputAttribute(
474 hConsoleOutput: HANDLE,
475 wAttribute: WORD,
476 nLength: DWORD,
477 dwWriteCoord: COORD,
478 lpNumberOfAttrsWritten: *DWORD,
340479) callconv(WINAPI) BOOL;
341480
342pub extern "kernel32" fn SetFilePointerEx(
343 in_fFile: HANDLE,
344 in_liDistanceToMove: LARGE_INTEGER,
345 out_opt_ldNewFilePointer: ?*LARGE_INTEGER,
346 in_dwMoveMethod: DWORD,
481pub extern "kernel32" fn FillConsoleOutputCharacterW(
482 hConsoleOutput: HANDLE,
483 cCharacter: WCHAR,
484 nLength: DWORD,
485 dwWriteCoord: COORD,
486 lpNumberOfCharsWritten: *DWORD,
347487) callconv(WINAPI) BOOL;
348488
349pub extern "kernel32" fn SetFileTime(
350 hFile: HANDLE,
351 lpCreationTime: ?*const FILETIME,
352 lpLastAccessTime: ?*const FILETIME,
353 lpLastWriteTime: ?*const FILETIME,
489pub extern "kernel32" fn SetConsoleCursorPosition(
490 hConsoleOutput: HANDLE,
491 dwCursorPosition: COORD,
354492) callconv(WINAPI) BOOL;
355493
356pub extern "kernel32" fn SetHandleInformation(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) callconv(WINAPI) BOOL;
494pub extern "kernel32" fn WriteConsoleW(
495 hConsoleOutput: HANDLE,
496 lpBuffer: [*]const u16,
497 nNumberOfCharsToWrite: DWORD,
498 lpNumberOfCharsWritten: ?*DWORD,
499 lpReserved: ?LPVOID,
500) callconv(WINAPI) BOOL;
357501
358pub extern "kernel32" fn Sleep(dwMilliseconds: DWORD) callconv(WINAPI) void;
502pub extern "kernel32" fn ReadConsoleOutputCharacterW(
503 hConsoleOutput: HANDLE,
504 lpCharacter: [*]u16,
505 nLength: DWORD,
506 dwReadCoord: COORD,
507 lpNumberOfCharsRead: *DWORD,
508) callconv(windows.WINAPI) BOOL;
509
510// Memory Mapping/Allocation
511
512// TODO: Wrapper around RtlCreateHeap.
513pub extern "kernel32" fn HeapCreate(
514 flOptions: DWORD,
515 dwInitialSize: SIZE_T,
516 dwMaximumSize: SIZE_T,
517) callconv(WINAPI) ?HANDLE;
359518
360pub extern "kernel32" fn SwitchToThread() callconv(WINAPI) BOOL;
519// TODO: Wrapper around RtlDestroyHeap (BOOLEAN -> BOOL).
520pub extern "kernel32" fn HeapDestroy(
521 hHeap: HANDLE,
522) callconv(WINAPI) BOOL;
361523
362pub extern "kernel32" fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) callconv(WINAPI) BOOL;
524// TODO: Forwarder to RtlReAllocateHeap.
525pub extern "kernel32" fn HeapReAlloc(
526 hHeap: HANDLE,
527 dwFlags: DWORD,
528 lpMem: *anyopaque,
529 dwBytes: SIZE_T,
530) callconv(WINAPI) ?*anyopaque;
363531
364pub extern "kernel32" fn TlsAlloc() callconv(WINAPI) DWORD;
532// TODO: Fowrarder to RtlAllocateHeap.
533pub extern "kernel32" fn HeapAlloc(
534 hHeap: HANDLE,
535 dwFlags: DWORD,
536 dwBytes: SIZE_T,
537) callconv(WINAPI) ?*anyopaque;
365538
366pub extern "kernel32" fn TlsFree(dwTlsIndex: DWORD) callconv(WINAPI) BOOL;
539// TODO: Fowrarder to RtlFreeHeap.
540pub extern "kernel32" fn HeapFree(
541 hHeap: HANDLE,
542 dwFlags: DWORD,
543 lpMem: LPVOID,
544) callconv(WINAPI) BOOL;
367545
368pub extern "kernel32" fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) callconv(WINAPI) DWORD;
546// TODO: Wrapper around RtlValidateHeap (BOOLEAN -> BOOL)
547pub extern "kernel32" fn HeapValidate(
548 hHeap: HANDLE,
549 dwFlags: DWORD,
550 lpMem: ?*const anyopaque,
551) callconv(WINAPI) BOOL;
369552
370pub extern "kernel32" fn WaitForSingleObjectEx(hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL) callconv(WINAPI) DWORD;
553// TODO: Wrapper around NtAllocateVirtualMemory.
554pub extern "kernel32" fn VirtualAlloc(
555 lpAddress: ?LPVOID,
556 dwSize: SIZE_T,
557 flAllocationType: DWORD,
558 flProtect: DWORD,
559) callconv(WINAPI) ?LPVOID;
560
561// TODO: Wrapper around NtFreeVirtualMemory.
562// If the return value is .INVALID_PAGE_PROTECTION, calls RtlFlushSecureMemoryCache and try again.
563pub extern "kernel32" fn VirtualFree(
564 lpAddress: ?LPVOID,
565 dwSize: SIZE_T,
566 dwFreeType: DWORD,
567) callconv(WINAPI) BOOL;
371568
372pub extern "kernel32" fn WaitForMultipleObjects(nCount: DWORD, lpHandle: [*]const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD) callconv(WINAPI) DWORD;
569// TODO: Wrapper around NtQueryVirtualMemory.
570pub extern "kernel32" fn VirtualQuery(
571 lpAddress: ?LPVOID,
572 lpBuffer: PMEMORY_BASIC_INFORMATION,
573 dwLength: SIZE_T,
574) callconv(WINAPI) SIZE_T;
373575
374pub extern "kernel32" fn WaitForMultipleObjectsEx(
375 nCount: DWORD,
376 lpHandle: [*]const HANDLE,
377 bWaitAll: BOOL,
378 dwMilliseconds: DWORD,
379 bAlertable: BOOL,
576pub extern "kernel32" fn LocalFree(
577 hMem: HLOCAL,
578) callconv(WINAPI) ?HLOCAL;
579
580// TODO: Getter for peb.ProcessHeap
581pub extern "kernel32" fn GetProcessHeap() callconv(WINAPI) ?HANDLE;
582
583// Code Libraries/Modules
584
585// TODO: Wrapper around LdrGetDllFullName.
586pub extern "kernel32" fn GetModuleFileNameW(
587 hModule: ?HMODULE,
588 lpFilename: LPWSTR,
589 nSize: DWORD,
380590) callconv(WINAPI) DWORD;
381591
382pub extern "kernel32" fn WriteFile(
383 in_hFile: HANDLE,
384 in_lpBuffer: [*]const u8,
385 in_nNumberOfBytesToWrite: DWORD,
386 out_lpNumberOfBytesWritten: ?*DWORD,
387 in_out_lpOverlapped: ?*OVERLAPPED,
592extern "kernel32" fn K32GetModuleFileNameExW(
593 hProcess: HANDLE,
594 hModule: ?HMODULE,
595 lpFilename: LPWSTR,
596 nSize: DWORD,
597) callconv(WINAPI) DWORD;
598pub const GetModuleFileNameExW = K32GetModuleFileNameExW;
599
600// TODO: Wrapper around ntdll.LdrGetDllHandle, which is a wrapper around LdrGetDllHandleEx
601pub extern "kernel32" fn GetModuleHandleW(
602 lpModuleName: ?LPCWSTR,
603) callconv(WINAPI) ?HMODULE;
604
605pub extern "kernel32" fn Module32First(
606 hSnapshot: HANDLE,
607 lpme: *MODULEENTRY32,
388608) callconv(WINAPI) BOOL;
389609
390pub extern "kernel32" fn WriteFileEx(
391 hFile: HANDLE,
392 lpBuffer: [*]const u8,
393 nNumberOfBytesToWrite: DWORD,
394 lpOverlapped: *OVERLAPPED,
395 lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
396) callconv(WINAPI) BOOL;
397
398pub extern "kernel32" fn LoadLibraryW(lpLibFileName: [*:0]const u16) callconv(WINAPI) ?HMODULE;
399pub extern "kernel32" fn LoadLibraryExW(lpLibFileName: [*:0]const u16, hFile: ?HANDLE, dwFlags: DWORD) callconv(WINAPI) ?HMODULE;
400
401pub extern "kernel32" fn GetProcAddress(hModule: HMODULE, lpProcName: [*:0]const u8) callconv(WINAPI) ?FARPROC;
402
403pub extern "kernel32" fn FreeLibrary(hModule: HMODULE) callconv(WINAPI) BOOL;
404
405pub extern "kernel32" fn InitializeCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(WINAPI) void;
406pub extern "kernel32" fn EnterCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(WINAPI) void;
407pub extern "kernel32" fn LeaveCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(WINAPI) void;
408pub extern "kernel32" fn DeleteCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(WINAPI) void;
409
410pub extern "kernel32" fn InitOnceExecuteOnce(InitOnce: *INIT_ONCE, InitFn: INIT_ONCE_FN, Parameter: ?*anyopaque, Context: ?*anyopaque) callconv(WINAPI) BOOL;
411
412pub extern "kernel32" fn K32EmptyWorkingSet(hProcess: HANDLE) callconv(WINAPI) BOOL;
413pub extern "kernel32" fn K32EnumDeviceDrivers(lpImageBase: [*]LPVOID, cb: DWORD, lpcbNeeded: *DWORD) callconv(WINAPI) BOOL;
414pub extern "kernel32" fn K32EnumPageFilesA(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID) callconv(WINAPI) BOOL;
415pub extern "kernel32" fn K32EnumPageFilesW(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID) callconv(WINAPI) BOOL;
416pub extern "kernel32" fn K32EnumProcessModules(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: *DWORD) callconv(WINAPI) BOOL;
417pub extern "kernel32" fn K32EnumProcessModulesEx(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: *DWORD, dwFilterFlag: DWORD) callconv(WINAPI) BOOL;
418pub extern "kernel32" fn K32EnumProcesses(lpidProcess: [*]DWORD, cb: DWORD, cbNeeded: *DWORD) callconv(WINAPI) BOOL;
419pub extern "kernel32" fn K32GetDeviceDriverBaseNameA(ImageBase: LPVOID, lpBaseName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
420pub extern "kernel32" fn K32GetDeviceDriverBaseNameW(ImageBase: LPVOID, lpBaseName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
421pub extern "kernel32" fn K32GetDeviceDriverFileNameA(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
422pub extern "kernel32" fn K32GetDeviceDriverFileNameW(ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
423pub extern "kernel32" fn K32GetMappedFileNameA(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
424pub extern "kernel32" fn K32GetMappedFileNameW(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
425pub extern "kernel32" fn K32GetModuleBaseNameA(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
426pub extern "kernel32" fn K32GetModuleBaseNameW(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
427pub extern "kernel32" fn K32GetModuleFileNameExA(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
428pub extern "kernel32" fn K32GetModuleFileNameExW(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
429pub extern "kernel32" fn K32GetModuleInformation(hProcess: HANDLE, hModule: HMODULE, lpmodinfo: *MODULEINFO, cb: DWORD) callconv(WINAPI) BOOL;
430pub extern "kernel32" fn K32GetPerformanceInfo(pPerformanceInformation: *PERFORMANCE_INFORMATION, cb: DWORD) callconv(WINAPI) BOOL;
431pub extern "kernel32" fn K32GetProcessImageFileNameA(hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
432pub extern "kernel32" fn K32GetProcessImageFileNameW(hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
433pub extern "kernel32" fn K32GetProcessMemoryInfo(Process: HANDLE, ppsmemCounters: *PROCESS_MEMORY_COUNTERS, cb: DWORD) callconv(WINAPI) BOOL;
434pub extern "kernel32" fn K32GetWsChanges(hProcess: HANDLE, lpWatchInfo: *PSAPI_WS_WATCH_INFORMATION, cb: DWORD) callconv(WINAPI) BOOL;
435pub extern "kernel32" fn K32GetWsChangesEx(hProcess: HANDLE, lpWatchInfoEx: *PSAPI_WS_WATCH_INFORMATION_EX, cb: DWORD) callconv(WINAPI) BOOL;
436pub extern "kernel32" fn K32InitializeProcessForWsWatch(hProcess: HANDLE) callconv(WINAPI) BOOL;
437pub extern "kernel32" fn K32QueryWorkingSet(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(WINAPI) BOOL;
438pub extern "kernel32" fn K32QueryWorkingSetEx(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(WINAPI) BOOL;
439
440pub extern "kernel32" fn FlushFileBuffers(hFile: HANDLE) callconv(WINAPI) BOOL;
441
442pub extern "kernel32" fn WakeAllConditionVariable(c: *CONDITION_VARIABLE) callconv(WINAPI) void;
443pub extern "kernel32" fn WakeConditionVariable(c: *CONDITION_VARIABLE) callconv(WINAPI) void;
444pub extern "kernel32" fn SleepConditionVariableSRW(
445 c: *CONDITION_VARIABLE,
446 s: *SRWLOCK,
447 t: DWORD,
448 f: ULONG,
610pub extern "kernel32" fn Module32Next(
611 hSnapshot: HANDLE,
612 lpme: *MODULEENTRY32,
449613) callconv(WINAPI) BOOL;
450614
451pub extern "kernel32" fn TryAcquireSRWLockExclusive(s: *SRWLOCK) callconv(WINAPI) BOOLEAN;
452pub extern "kernel32" fn AcquireSRWLockExclusive(s: *SRWLOCK) callconv(WINAPI) void;
453pub extern "kernel32" fn ReleaseSRWLockExclusive(s: *SRWLOCK) callconv(WINAPI) void;
615pub extern "kernel32" fn LoadLibraryW(
616 lpLibFileName: LPCWSTR,
617) callconv(WINAPI) ?HMODULE;
618
619pub extern "kernel32" fn LoadLibraryExW(
620 lpLibFileName: LPCWSTR,
621 hFile: ?HANDLE,
622 dwFlags: DWORD,
623) callconv(WINAPI) ?HMODULE;
624
625pub extern "kernel32" fn GetProcAddress(
626 hModule: HMODULE,
627 lpProcName: LPCSTR,
628) callconv(WINAPI) ?FARPROC;
629
630pub extern "kernel32" fn FreeLibrary(
631 hModule: HMODULE,
632) callconv(WINAPI) BOOL;
633
634// Error Management
635
636pub extern "kernel32" fn FormatMessageW(
637 dwFlags: DWORD,
638 lpSource: ?LPCVOID,
639 dwMessageId: Win32Error,
640 dwLanguageId: DWORD,
641 lpBuffer: LPWSTR,
642 nSize: DWORD,
643 Arguments: ?*va_list,
644) callconv(WINAPI) DWORD;
645
646// TODO: Getter for teb().LastErrorValue.
647pub extern "kernel32" fn GetLastError() callconv(WINAPI) Win32Error;
648
649// TODO: Wrapper around RtlSetLastWin32Error.
650pub extern "kernel32" fn SetLastError(
651 dwErrCode: Win32Error,
652) callconv(WINAPI) void;
454653
455pub extern "kernel32" fn RegOpenKeyExW(
456 hkey: HKEY,
457 lpSubKey: LPCWSTR,
458 ulOptions: DWORD,
459 samDesired: REGSAM,
460 phkResult: *HKEY,
461) callconv(WINAPI) LSTATUS;
654// Everything Else
462655
463pub extern "kernel32" fn GetPhysicallyInstalledSystemMemory(TotalMemoryInKilobytes: *ULONGLONG) BOOL;
656// TODO:
657// Wrapper around KUSER_SHARED_DATA.SystemTime.
658// Much better to use NtQuerySystemTime or NtQuerySystemTimePrecise for guaranteed 0.1ns precision.
659pub extern "kernel32" fn GetSystemTimeAsFileTime(
660 lpSystemTimeAsFileTime: *FILETIME,
661) callconv(WINAPI) void;