master
1const std = @import("../../std.zig");
2const windows = std.os.windows;
3
4const BOOL = windows.BOOL;
5const CONDITION_VARIABLE = windows.CONDITION_VARIABLE;
6const CONSOLE_SCREEN_BUFFER_INFO = windows.CONSOLE_SCREEN_BUFFER_INFO;
7const COORD = windows.COORD;
8const DWORD = windows.DWORD;
9const FARPROC = windows.FARPROC;
10const FILETIME = windows.FILETIME;
11const HANDLE = windows.HANDLE;
12const HANDLER_ROUTINE = windows.HANDLER_ROUTINE;
13const HMODULE = windows.HMODULE;
14const INIT_ONCE = windows.INIT_ONCE;
15const INIT_ONCE_FN = windows.INIT_ONCE_FN;
16const LARGE_INTEGER = windows.LARGE_INTEGER;
17const LPCSTR = windows.LPCSTR;
18const LPCVOID = windows.LPCVOID;
19const LPCWSTR = windows.LPCWSTR;
20const LPTHREAD_START_ROUTINE = windows.LPTHREAD_START_ROUTINE;
21const LPVOID = windows.LPVOID;
22const LPWSTR = windows.LPWSTR;
23const MODULEENTRY32 = windows.MODULEENTRY32;
24const OVERLAPPED = windows.OVERLAPPED;
25const OVERLAPPED_ENTRY = windows.OVERLAPPED_ENTRY;
26const PMEMORY_BASIC_INFORMATION = windows.PMEMORY_BASIC_INFORMATION;
27const PROCESS_INFORMATION = windows.PROCESS_INFORMATION;
28const SECURITY_ATTRIBUTES = windows.SECURITY_ATTRIBUTES;
29const SIZE_T = windows.SIZE_T;
30const SRWLOCK = windows.SRWLOCK;
31const STARTUPINFOW = windows.STARTUPINFOW;
32const SYSTEM_INFO = windows.SYSTEM_INFO;
33const UCHAR = windows.UCHAR;
34const UINT = windows.UINT;
35const ULONG = windows.ULONG;
36const ULONG_PTR = windows.ULONG_PTR;
37const va_list = windows.va_list;
38const WCHAR = windows.WCHAR;
39const WIN32_FIND_DATAW = windows.WIN32_FIND_DATAW;
40const Win32Error = windows.Win32Error;
41const WORD = windows.WORD;
42
43// I/O - Filesystem
44
45pub extern "kernel32" fn ReadDirectoryChangesW(
46 hDirectory: HANDLE,
47 lpBuffer: [*]align(@alignOf(windows.FILE_NOTIFY_INFORMATION)) u8,
48 nBufferLength: DWORD,
49 bWatchSubtree: BOOL,
50 dwNotifyFilter: windows.FileNotifyChangeFilter,
51 lpBytesReturned: ?*DWORD,
52 lpOverlapped: ?*OVERLAPPED,
53 lpCompletionRoutine: windows.LPOVERLAPPED_COMPLETION_ROUTINE,
54) callconv(.winapi) BOOL;
55
56// TODO: Wrapper around NtCancelIoFile.
57pub extern "kernel32" fn CancelIo(
58 hFile: HANDLE,
59) callconv(.winapi) BOOL;
60
61// TODO: Wrapper around NtCancelIoFileEx.
62pub extern "kernel32" fn CancelIoEx(
63 hFile: HANDLE,
64 lpOverlapped: ?*OVERLAPPED,
65) callconv(.winapi) BOOL;
66
67pub extern "kernel32" fn CreateFileW(
68 lpFileName: LPCWSTR,
69 dwDesiredAccess: DWORD,
70 dwShareMode: DWORD,
71 lpSecurityAttributes: ?*SECURITY_ATTRIBUTES,
72 dwCreationDisposition: DWORD,
73 dwFlagsAndAttributes: DWORD,
74 hTemplateFile: ?HANDLE,
75) callconv(.winapi) HANDLE;
76
77// TODO A bunch of logic around NtCreateNamedPipe
78pub extern "kernel32" fn CreateNamedPipeW(
79 lpName: LPCWSTR,
80 dwOpenMode: DWORD,
81 dwPipeMode: DWORD,
82 nMaxInstances: DWORD,
83 nOutBufferSize: DWORD,
84 nInBufferSize: DWORD,
85 nDefaultTimeOut: DWORD,
86 lpSecurityAttributes: ?*const SECURITY_ATTRIBUTES,
87) callconv(.winapi) HANDLE;
88
89// TODO: Matches `STD_*_HANDLE` to peb().ProcessParameters.Standard*
90pub extern "kernel32" fn GetStdHandle(
91 nStdHandle: DWORD,
92) callconv(.winapi) ?HANDLE;
93
94// TODO: Wrapper around NtSetInformationFile + `FILE_POSITION_INFORMATION`.
95// `FILE_STANDARD_INFORMATION` is also used if dwMoveMethod is `FILE_END`
96pub extern "kernel32" fn SetFilePointerEx(
97 hFile: HANDLE,
98 liDistanceToMove: LARGE_INTEGER,
99 lpNewFilePointer: ?*LARGE_INTEGER,
100 dwMoveMethod: DWORD,
101) callconv(.winapi) BOOL;
102
103// TODO: Wrapper around NtSetInformationFile + `FILE_BASIC_INFORMATION`
104pub extern "kernel32" fn SetFileTime(
105 hFile: HANDLE,
106 lpCreationTime: ?*const FILETIME,
107 lpLastAccessTime: ?*const FILETIME,
108 lpLastWriteTime: ?*const FILETIME,
109) callconv(.winapi) BOOL;
110
111pub extern "kernel32" fn WriteFile(
112 in_hFile: HANDLE,
113 in_lpBuffer: [*]const u8,
114 in_nNumberOfBytesToWrite: DWORD,
115 out_lpNumberOfBytesWritten: ?*DWORD,
116 in_out_lpOverlapped: ?*OVERLAPPED,
117) callconv(.winapi) BOOL;
118
119// TODO: wrapper for NtQueryInformationFile + `FILE_STANDARD_INFORMATION`
120pub extern "kernel32" fn GetFileSizeEx(
121 hFile: HANDLE,
122 lpFileSize: *LARGE_INTEGER,
123) callconv(.winapi) BOOL;
124
125// TODO: Wrapper around GetStdHandle + NtFlushBuffersFile.
126pub extern "kernel32" fn FlushFileBuffers(
127 hFile: HANDLE,
128) callconv(.winapi) BOOL;
129
130// TODO: Wrapper around NtSetInformationFile + `FILE_IO_COMPLETION_NOTIFICATION_INFORMATION`.
131pub extern "kernel32" fn SetFileCompletionNotificationModes(
132 FileHandle: HANDLE,
133 Flags: UCHAR,
134) callconv(.winapi) BOOL;
135
136// TODO: `RtlGetCurrentDirectory_U(nBufferLength * 2, lpBuffer)`
137pub extern "kernel32" fn GetCurrentDirectoryW(
138 nBufferLength: DWORD,
139 lpBuffer: ?[*]WCHAR,
140) callconv(.winapi) DWORD;
141
142pub extern "kernel32" fn ReadFile(
143 hFile: HANDLE,
144 lpBuffer: LPVOID,
145 nNumberOfBytesToRead: DWORD,
146 lpNumberOfBytesRead: ?*DWORD,
147 lpOverlapped: ?*OVERLAPPED,
148) callconv(.winapi) BOOL;
149
150pub extern "kernel32" fn GetSystemDirectoryW(
151 lpBuffer: LPWSTR,
152 uSize: UINT,
153) callconv(.winapi) UINT;
154
155// I/O - Kernel Objects
156
157// TODO: Wrapper around GetStdHandle + NtDuplicateObject.
158pub extern "kernel32" fn DuplicateHandle(
159 hSourceProcessHandle: HANDLE,
160 hSourceHandle: HANDLE,
161 hTargetProcessHandle: HANDLE,
162 lpTargetHandle: *HANDLE,
163 dwDesiredAccess: DWORD,
164 bInheritHandle: BOOL,
165 dwOptions: DWORD,
166) callconv(.winapi) BOOL;
167
168// TODO: Wrapper around GetStdHandle + NtQueryObject + NtSetInformationObject with .ObjectHandleFlagInformation.
169pub extern "kernel32" fn SetHandleInformation(
170 hObject: HANDLE,
171 dwMask: DWORD,
172 dwFlags: DWORD,
173) callconv(.winapi) BOOL;
174
175// TODO: Wrapper around NtRemoveIoCompletion.
176pub extern "kernel32" fn GetQueuedCompletionStatus(
177 CompletionPort: HANDLE,
178 lpNumberOfBytesTransferred: *DWORD,
179 lpCompletionKey: *ULONG_PTR,
180 lpOverlapped: *?*OVERLAPPED,
181 dwMilliseconds: DWORD,
182) callconv(.winapi) BOOL;
183
184// TODO: Wrapper around NtRemoveIoCompletionEx.
185pub extern "kernel32" fn GetQueuedCompletionStatusEx(
186 CompletionPort: HANDLE,
187 lpCompletionPortEntries: [*]OVERLAPPED_ENTRY,
188 ulCount: ULONG,
189 ulNumEntriesRemoved: *ULONG,
190 dwMilliseconds: DWORD,
191 fAlertable: BOOL,
192) callconv(.winapi) BOOL;
193
194// TODO: Wrapper around NtSetIoCompletion with `IoStatus = .SUCCESS`.
195pub extern "kernel32" fn PostQueuedCompletionStatus(
196 CompletionPort: HANDLE,
197 dwNumberOfBytesTransferred: DWORD,
198 dwCompletionKey: ULONG_PTR,
199 lpOverlapped: ?*OVERLAPPED,
200) callconv(.winapi) BOOL;
201
202// TODO:
203// GetOverlappedResultEx with bAlertable=false, which calls: GetStdHandle + WaitForSingleObjectEx.
204// Uses the SwitchBack system to run implementations for older programs; Do we care about this?
205pub extern "kernel32" fn GetOverlappedResult(
206 hFile: HANDLE,
207 lpOverlapped: *OVERLAPPED,
208 lpNumberOfBytesTransferred: *DWORD,
209 bWait: BOOL,
210) callconv(.winapi) BOOL;
211
212// TODO: Wrapper around NtCreateIoCompletion + NtSetInformationFile with FILE_COMPLETION_INFORMATION.
213// This would be better splitting into two functions.
214pub extern "kernel32" fn CreateIoCompletionPort(
215 FileHandle: HANDLE,
216 ExistingCompletionPort: ?HANDLE,
217 CompletionKey: ULONG_PTR,
218 NumberOfConcurrentThreads: DWORD,
219) callconv(.winapi) ?HANDLE;
220
221// TODO: Wrapper around RtlReportSilentProcessExit + NtTerminateProcess.
222pub extern "kernel32" fn TerminateProcess(
223 hProcess: HANDLE,
224 uExitCode: UINT,
225) callconv(.winapi) BOOL;
226
227// TODO: WaitForSingleObjectEx with bAlertable=false.
228pub extern "kernel32" fn WaitForSingleObject(
229 hHandle: HANDLE,
230 dwMilliseconds: DWORD,
231) callconv(.winapi) DWORD;
232
233// TODO: Wrapper for GetStdHandle + NtWaitForSingleObject.
234// Sets up an activation context before calling NtWaitForSingleObject.
235pub extern "kernel32" fn WaitForSingleObjectEx(
236 hHandle: HANDLE,
237 dwMilliseconds: DWORD,
238 bAlertable: BOOL,
239) callconv(.winapi) DWORD;
240
241// TODO: WaitForMultipleObjectsEx with alertable=false
242pub extern "kernel32" fn WaitForMultipleObjects(
243 nCount: DWORD,
244 lpHandle: [*]const HANDLE,
245 bWaitAll: BOOL,
246 dwMilliseconds: DWORD,
247) callconv(.winapi) DWORD;
248
249// TODO: Wrapper around NtWaitForMultipleObjects.
250pub extern "kernel32" fn WaitForMultipleObjectsEx(
251 nCount: DWORD,
252 lpHandle: [*]const HANDLE,
253 bWaitAll: BOOL,
254 dwMilliseconds: DWORD,
255 bAlertable: BOOL,
256) callconv(.winapi) DWORD;
257
258// Process Management
259
260pub extern "kernel32" fn CreateProcessW(
261 lpApplicationName: ?LPCWSTR,
262 lpCommandLine: ?LPWSTR,
263 lpProcessAttributes: ?*SECURITY_ATTRIBUTES,
264 lpThreadAttributes: ?*SECURITY_ATTRIBUTES,
265 bInheritHandles: BOOL,
266 dwCreationFlags: windows.CreateProcessFlags,
267 lpEnvironment: ?LPVOID,
268 lpCurrentDirectory: ?LPCWSTR,
269 lpStartupInfo: *STARTUPINFOW,
270 lpProcessInformation: *PROCESS_INFORMATION,
271) callconv(.winapi) BOOL;
272
273// TODO: implement via ntdll instead
274pub extern "kernel32" fn SleepEx(
275 dwMilliseconds: DWORD,
276 bAlertable: BOOL,
277) callconv(.winapi) DWORD;
278
279// TODO: Wrapper around NtQueryInformationProcess with `PROCESS_BASIC_INFORMATION`.
280pub extern "kernel32" fn GetExitCodeProcess(
281 hProcess: HANDLE,
282 lpExitCode: *DWORD,
283) callconv(.winapi) BOOL;
284
285// TODO: Wrapper around RtlSetEnvironmentVar.
286pub extern "kernel32" fn SetEnvironmentVariableW(
287 lpName: LPCWSTR,
288 lpValue: ?LPCWSTR,
289) callconv(.winapi) BOOL;
290
291pub extern "kernel32" fn CreateToolhelp32Snapshot(
292 dwFlags: DWORD,
293 th32ProcessID: DWORD,
294) callconv(.winapi) HANDLE;
295
296// Threading
297
298// TODO: Already a wrapper for this, see `windows.GetCurrentThreadId`.
299pub extern "kernel32" fn GetCurrentThreadId() callconv(.winapi) DWORD;
300
301// TODO: CreateRemoteThread with hProcess=NtCurrentProcess().
302pub extern "kernel32" fn CreateThread(
303 lpThreadAttributes: ?*SECURITY_ATTRIBUTES,
304 dwStackSize: SIZE_T,
305 lpStartAddress: LPTHREAD_START_ROUTINE,
306 lpParameter: ?LPVOID,
307 dwCreationFlags: DWORD,
308 lpThreadId: ?*DWORD,
309) callconv(.winapi) ?HANDLE;
310
311// TODO: Wrapper around RtlDelayExecution.
312pub extern "kernel32" fn SwitchToThread() callconv(.winapi) BOOL;
313
314// Locks, critical sections, initializers
315
316pub extern "kernel32" fn InitOnceExecuteOnce(
317 InitOnce: *INIT_ONCE,
318 InitFn: INIT_ONCE_FN,
319 Parameter: ?*anyopaque,
320 Context: ?*anyopaque,
321) callconv(.winapi) BOOL;
322
323// TODO:
324// - dwMilliseconds -> LARGE_INTEGER.
325// - RtlSleepConditionVariableSRW
326// - return rc != .TIMEOUT
327pub extern "kernel32" fn SleepConditionVariableSRW(
328 ConditionVariable: *CONDITION_VARIABLE,
329 SRWLock: *SRWLOCK,
330 dwMilliseconds: DWORD,
331 Flags: ULONG,
332) callconv(.winapi) BOOL;
333
334// Console management
335
336pub extern "kernel32" fn GetConsoleMode(
337 hConsoleHandle: HANDLE,
338 lpMode: *DWORD,
339) callconv(.winapi) BOOL;
340
341pub extern "kernel32" fn SetConsoleMode(
342 hConsoleHandle: HANDLE,
343 dwMode: DWORD,
344) callconv(.winapi) BOOL;
345
346pub extern "kernel32" fn GetConsoleScreenBufferInfo(
347 hConsoleOutput: HANDLE,
348 lpConsoleScreenBufferInfo: *CONSOLE_SCREEN_BUFFER_INFO,
349) callconv(.winapi) BOOL;
350
351pub extern "kernel32" fn SetConsoleTextAttribute(
352 hConsoleOutput: HANDLE,
353 wAttributes: WORD,
354) callconv(.winapi) BOOL;
355
356pub extern "kernel32" fn SetConsoleCtrlHandler(
357 HandlerRoutine: ?HANDLER_ROUTINE,
358 Add: BOOL,
359) callconv(.winapi) BOOL;
360
361pub extern "kernel32" fn SetConsoleOutputCP(
362 wCodePageID: UINT,
363) callconv(.winapi) BOOL;
364
365pub extern "kernel32" fn GetConsoleOutputCP() callconv(.winapi) UINT;
366
367pub extern "kernel32" fn FillConsoleOutputAttribute(
368 hConsoleOutput: HANDLE,
369 wAttribute: WORD,
370 nLength: DWORD,
371 dwWriteCoord: COORD,
372 lpNumberOfAttrsWritten: *DWORD,
373) callconv(.winapi) BOOL;
374
375pub extern "kernel32" fn FillConsoleOutputCharacterW(
376 hConsoleOutput: HANDLE,
377 cCharacter: WCHAR,
378 nLength: DWORD,
379 dwWriteCoord: COORD,
380 lpNumberOfCharsWritten: *DWORD,
381) callconv(.winapi) BOOL;
382
383pub extern "kernel32" fn SetConsoleCursorPosition(
384 hConsoleOutput: HANDLE,
385 dwCursorPosition: COORD,
386) callconv(.winapi) BOOL;
387
388pub extern "kernel32" fn WriteConsoleW(
389 hConsoleOutput: HANDLE,
390 lpBuffer: [*]const u16,
391 nNumberOfCharsToWrite: DWORD,
392 lpNumberOfCharsWritten: ?*DWORD,
393 lpReserved: ?LPVOID,
394) callconv(.winapi) BOOL;
395
396pub extern "kernel32" fn ReadConsoleOutputCharacterW(
397 hConsoleOutput: HANDLE,
398 lpCharacter: [*]u16,
399 nLength: DWORD,
400 dwReadCoord: COORD,
401 lpNumberOfCharsRead: *DWORD,
402) callconv(.winapi) BOOL;
403
404// Memory Mapping/Allocation
405
406// TODO: Wrapper around RtlCreateHeap.
407pub extern "kernel32" fn HeapCreate(
408 flOptions: DWORD,
409 dwInitialSize: SIZE_T,
410 dwMaximumSize: SIZE_T,
411) callconv(.winapi) ?HANDLE;
412
413// TODO: Fowrarder to RtlFreeHeap before win11_zn.
414// Since win11_zn this function points to unexported symbol RtlFreeHeapFast.
415// See https://github.com/ziglang/zig/pull/25766#discussion_r2479727640
416pub extern "kernel32" fn HeapFree(
417 hHeap: HANDLE,
418 dwFlags: DWORD,
419 lpMem: LPVOID,
420) callconv(.winapi) BOOL;
421
422// TODO: Wrapper around RtlValidateHeap (BOOLEAN -> BOOL)
423pub extern "kernel32" fn HeapValidate(
424 hHeap: HANDLE,
425 dwFlags: DWORD,
426 lpMem: ?*const anyopaque,
427) callconv(.winapi) BOOL;
428
429// TODO: Getter for peb.ProcessHeap
430pub extern "kernel32" fn GetProcessHeap() callconv(.winapi) ?HANDLE;
431
432// Code Libraries/Modules
433
434// TODO: Wrapper around LdrGetDllFullName.
435pub extern "kernel32" fn GetModuleFileNameW(
436 hModule: ?HMODULE,
437 lpFilename: [*]WCHAR,
438 nSize: DWORD,
439) callconv(.winapi) DWORD;
440
441extern "kernel32" fn K32GetModuleFileNameExW(
442 hProcess: HANDLE,
443 hModule: ?HMODULE,
444 lpFilename: LPWSTR,
445 nSize: DWORD,
446) callconv(.winapi) DWORD;
447pub const GetModuleFileNameExW = K32GetModuleFileNameExW;
448
449// TODO: Wrapper around ntdll.LdrGetDllHandle, which is a wrapper around LdrGetDllHandleEx
450pub extern "kernel32" fn GetModuleHandleW(
451 lpModuleName: ?LPCWSTR,
452) callconv(.winapi) ?HMODULE;
453
454pub extern "kernel32" fn Module32First(
455 hSnapshot: HANDLE,
456 lpme: *MODULEENTRY32,
457) callconv(.winapi) BOOL;
458
459pub extern "kernel32" fn Module32Next(
460 hSnapshot: HANDLE,
461 lpme: *MODULEENTRY32,
462) callconv(.winapi) BOOL;
463
464pub extern "kernel32" fn LoadLibraryW(
465 lpLibFileName: LPCWSTR,
466) callconv(.winapi) ?HMODULE;
467
468pub extern "kernel32" fn LoadLibraryExW(
469 lpLibFileName: LPCWSTR,
470 hFile: ?HANDLE,
471 dwFlags: DWORD,
472) callconv(.winapi) ?HMODULE;
473
474pub extern "kernel32" fn GetProcAddress(
475 hModule: HMODULE,
476 lpProcName: LPCSTR,
477) callconv(.winapi) ?FARPROC;
478
479pub extern "kernel32" fn FreeLibrary(
480 hModule: HMODULE,
481) callconv(.winapi) BOOL;
482
483// Error Management
484
485pub extern "kernel32" fn FormatMessageW(
486 dwFlags: DWORD,
487 lpSource: ?LPCVOID,
488 dwMessageId: Win32Error,
489 dwLanguageId: DWORD,
490 lpBuffer: LPWSTR,
491 nSize: DWORD,
492 Arguments: ?*va_list,
493) callconv(.winapi) DWORD;
494
495// TODO: Getter for teb().LastErrorValue.
496pub extern "kernel32" fn GetLastError() callconv(.winapi) Win32Error;
497
498// TODO: Wrapper around RtlSetLastWin32Error.
499pub extern "kernel32" fn SetLastError(
500 dwErrCode: Win32Error,
501) callconv(.winapi) void;
502
503// Everything Else
504
505pub extern "kernel32" fn GetSystemInfo(
506 lpSystemInfo: *SYSTEM_INFO,
507) callconv(.winapi) void;