kernel32 Topic

Functions

ActivateActCtx(int hActCtx, Pointer<IntPtr> lpCookie) → int kernel32

The ActivateActCtx function activates the specified activation context. It does this by pushing the specified activation context to the top of the activation stack. The specified activation context is thus associated with the current thread and any appropriate side-by-side API functions. [...]

AddRefActCtx(int hActCtx) → void kernel32

The AddRefActCtx function increments the reference count of the specified activation context. [...]

AllocConsole() → int kernel32

Allocates a new console for the calling process. [...]

AttachConsole(int dwProcessId) → int kernel32

Attaches the calling process to the console of the specified process. [...]

Beep(int dwFreq, int dwDuration) → int kernel32

Generates simple tones on the speaker. The function is synchronous; it performs an alertable wait and does not return control to its caller until the sound finishes. [...]

BeginUpdateResource(Pointer<Utf16> pFileName, int bDeleteExistingResources) → int kernel32

Retrieves a handle that can be used by the UpdateResource function to add, delete, or replace resources in a binary module. [...]

CheckRemoteDebuggerPresent(int hProcess, Pointer<Int32> pbDebuggerPresent) → int kernel32

Determines whether the specified process is being debugged. [...]

CloseHandle(int hObject) → int kernel32

Closes an open object handle. [...]

ClosePseudoConsole(int hPC) → void kernel32

Closes a pseudoconsole from the given handle. [...]

ContinueDebugEvent(int dwProcessId, int dwThreadId, int dwContinueStatus) → int kernel32

Enables a debugger to continue a thread that previously reported a debugging event. [...]

CreateActCtx(Pointer<ACTCTX> pActCtx) → int kernel32

The CreateActCtx function creates an activation context. [...]

CreateConsoleScreenBuffer(int dwDesiredAccess, int dwShareMode, Pointer<SECURITY_ATTRIBUTES> lpSecurityAttributes, int dwFlags, Pointer<NativeType> lpScreenBufferData) → int kernel32

Creates a console screen buffer. [...]

CreateDirectory(Pointer<Utf16> lpPathName, Pointer<SECURITY_ATTRIBUTES> lpSecurityAttributes) → int kernel32

Creates a new directory. If the underlying file system supports security on files and directories, the function applies a specified security descriptor to the new directory. [...]

CreateFile(Pointer<Utf16> lpFileName, int dwDesiredAccess, int dwShareMode, Pointer<SECURITY_ATTRIBUTES> lpSecurityAttributes, int dwCreationDisposition, int dwFlagsAndAttributes, int hTemplateFile) → int kernel32

Creates or opens a file or I/O device. The most commonly used I/O devices are as follows: file, file stream, directory, physical disk, volume, console buffer, tape drive, communications resource, mailslot, and pipe. The function returns a handle that can be used to access the file or device for various types of I/O depending on the file or device and the flags and attributes specified. [...]

CreatePipe(Pointer<IntPtr> hReadPipe, Pointer<IntPtr> hWritePipe, Pointer<SECURITY_ATTRIBUTES> lpPipeAttributes, int nSize) → int kernel32

Creates an anonymous pipe, and returns handles to the read and write ends of the pipe. [...]

CreateProcess(Pointer<Utf16> lpApplicationName, Pointer<Utf16> lpCommandLine, Pointer<SECURITY_ATTRIBUTES> lpProcessAttributes, Pointer<SECURITY_ATTRIBUTES> lpThreadAttributes, int bInheritHandles, int dwCreationFlags, Pointer<NativeType> lpEnvironment, Pointer<Utf16> lpCurrentDirectory, Pointer<STARTUPINFO> lpStartupInfo, Pointer<PROCESS_INFORMATION> lpProcessInformation) → int kernel32

Creates a new process and its primary thread. The new process runs in the security context of the calling process. [...]

CreatePseudoConsole(COORD size, int hInput, int hOutput, int dwFlags, Pointer<IntPtr> phPC) → int kernel32

Creates a new pseudoconsole object for the calling process. [...]

DeactivateActCtx(int dwFlags, int ulCookie) → int kernel32

The DeactivateActCtx function deactivates the activation context corresponding to the specified cookie. [...]

DebugBreak() → void kernel32

Causes a breakpoint exception to occur in the current process. This allows the calling thread to signal the debugger to handle the exception. [...]

DebugBreakProcess(int Process) → int kernel32

Causes a breakpoint exception to occur in the specified process. This allows the calling thread to signal the debugger to handle the exception. [...]

DebugSetProcessKillOnExit(int KillOnExit) → int kernel32

Sets the action to be performed when the calling thread exits. [...]

DeleteFile(Pointer<Utf16> lpFileName) → int kernel32

Deletes an existing file. [...]

EndUpdateResource(int hUpdate, int fDiscard) → int kernel32

Commits or discards changes made prior to a call to UpdateResource. [...]

EnumResourceNames(int hModule, Pointer<Utf16> lpType, Pointer<NativeFunction<EnumResNameProc>> lpEnumFunc, int lParam) → int kernel32

Enumerates resources of a specified type within a binary module. For Windows Vista and later, this is typically a language-neutral Portable Executable (LN file), and the enumeration will also include resources from the corresponding language-specific resource files (.mui files) that contain localizable language resources. It is also possible for hModule to specify an .mui file, in which case only that file is searched for resources. [...]

EnumResourceTypes(int hModule, Pointer<NativeFunction<EnumResTypeProc>> lpEnumFunc, int lParam) → int kernel32

Enumerates resource types within a binary module. Starting with Windows Vista, this is typically a language-neutral Portable Executable (LN file), and the enumeration also includes resources from one of the corresponding language-specific resource files (.mui files)—if one exists—that contain localizable language resources. It is also possible to use hModule to specify a .mui file, in which case only that file is searched for resource types. [...]

ExitProcess(int uExitCode) → void kernel32

Ends the calling process and all its threads. [...]

FillConsoleOutputAttribute(int hConsoleOutput, int wAttribute, int nLength, COORD dwWriteCoord, Pointer<Uint32> lpNumberOfAttrsWritten) → int kernel32

Sets the character attributes for a specified number of character cells, beginning at the specified coordinates in a screen buffer. [...]

FillConsoleOutputCharacter(int hConsoleOutput, int cCharacter, int nLength, COORD dwWriteCoord, Pointer<Uint32> lpNumberOfCharsWritten) → int kernel32

Writes a character to the console screen buffer a specified number of times, beginning at the specified coordinates. [...]

FindClose(int hFindFile) → int kernel32

Closes a file search handle opened by the FindFirstFile, FindFirstFileEx, FindFirstFileNameW, FindFirstFileNameTransactedW, FindFirstFileTransacted, FindFirstStreamTransactedW, or FindFirstStreamW functions. [...]

FindCloseChangeNotification(int hChangeHandle) → int kernel32

Stops change notification handle monitoring. [...]

FindFirstChangeNotification(Pointer<Utf16> lpPathName, int bWatchSubtree, int dwNotifyFilter) → int kernel32

Creates a change notification handle and sets up initial change notification filter conditions. A wait on a notification handle succeeds when a change matching the filter conditions occurs in the specified directory or subtree. The function does not report changes to the specified directory itself. [...]

FindFirstFile(Pointer<Utf16> lpFileName, Pointer<WIN32_FIND_DATA> lpFindFileData) → int kernel32

Searches a directory for a file or subdirectory with a name that matches a specific name (or partial name if wildcards are used). [...]

FindFirstVolume(Pointer<Utf16> lpszVolumeName, int cchBufferLength) → int kernel32

Retrieves the name of a volume on a computer. FindFirstVolume is used to begin scanning the volumes of a computer. [...]

FindNextChangeNotification(int hChangeHandle) → int kernel32

Requests that the operating system signal a change notification handle the next time it detects an appropriate change. [...]

FindNextFile(int hFindFile, Pointer<WIN32_FIND_DATA> lpFindFileData) → int kernel32

Continues a file search from a previous call to the FindFirstFile, FindFirstFileEx, or FindFirstFileTransacted functions. [...]

FindNextVolume(int hFindVolume, Pointer<Utf16> lpszVolumeName, int cchBufferLength) → int kernel32

Continues a volume search started by a call to the FindFirstVolume function. FindNextVolume finds one volume per call. [...]

FindResource(int hModule, Pointer<Utf16> lpName, Pointer<Utf16> lpType) → int kernel32

Determines the location of a resource with the specified type and name in the specified module. [...]

FindResourceEx(int hModule, Pointer<Utf16> lpType, Pointer<Utf16> lpName, int wLanguage) → int kernel32

Determines the location of the resource with the specified type, name, and language in the specified module. [...]

FindVolumeClose(int hFindVolume) → int kernel32

Closes the specified volume search handle. The FindFirstVolume and FindNextVolume functions use this search handle to locate volumes. [...]

FlushConsoleInputBuffer(int hConsoleInput) → int kernel32

Flushes the console input buffer. All input records currently in the input buffer are discarded. [...]

FormatMessage(int dwFlags, Pointer<NativeType> lpSource, int dwMessageId, int dwLanguageId, Pointer<Utf16> lpBuffer, int nSize, Pointer<NativeType> Arguments) → int kernel32

Formats a message string. The function requires a message definition as input. The message definition can come from a buffer passed into the function. It can come from a message table resource in an already-loaded module. Or the caller can ask the function to search the system's message table resource(s) for the message definition. The function finds the message definition in a message table resource based on a message identifier and a language identifier. The function copies the formatted message text to an output buffer, processing any embedded insert sequences if requested. [...]

FreeConsole() → int kernel32

Detaches the calling process from its console. [...]

FreeLibrary(int hLibModule) → int kernel32

Frees the loaded dynamic-link library (DLL) module and, if necessary, decrements its reference count. When the reference count reaches zero, the module is unloaded from the address space of the calling process and the handle is no longer valid. [...]

GetComputerNameEx(int NameType, Pointer<Utf16> lpBuffer, Pointer<Uint32> nSize) → int kernel32

Retrieves a NetBIOS or DNS name associated with the local computer. The names are established at system startup, when the system reads them from the registry. [...]

GetConsoleCursorInfo(int hConsoleOutput, Pointer<CONSOLE_CURSOR_INFO> lpConsoleCursorInfo) → int kernel32

Retrieves information about the size and visibility of the cursor for the specified console screen buffer. [...]

GetConsoleMode(int hConsoleHandle, Pointer<Uint32> lpMode) → int kernel32

Retrieves the current input mode of a console's input buffer or the current output mode of a console screen buffer. [...]

GetConsoleScreenBufferInfo(int hConsoleOutput, Pointer<CONSOLE_SCREEN_BUFFER_INFO> lpConsoleScreenBufferInfo) → int kernel32

Retrieves information about the specified console screen buffer. [...]

GetConsoleSelectionInfo(Pointer<CONSOLE_SELECTION_INFO> lpConsoleSelectionInfo) → int kernel32

Retrieves information about the current console selection. [...]

GetConsoleTitle(Pointer<Utf16> lpConsoleTitle, int nSize) → int kernel32

Retrieves the title for the current console window. [...]

GetConsoleWindow() → int kernel32

Retrieves the window handle used by the console associated with the calling process. [...]

GetCurrentActCtx(Pointer<IntPtr> lphActCtx) → int kernel32

The GetCurrentActCtx function returns the handle to the active activation context of the calling thread. [...]

GetCurrentProcess() → int kernel32

Retrieves a pseudo handle for the current process. [...]

GetFileAttributesEx(Pointer<Utf16> lpFileName, int fInfoLevelId, Pointer<NativeType> lpFileInformation) → int kernel32

Retrieves attributes for a specified file or directory. [...]

GetIntegratedDisplaySize(Pointer<Double> sizeInInches) → int kernel32

Retrieves the best estimate of the diagonal size of the built-in screen, in inches. [...]

GetLargestConsoleWindowSize(int hConsoleOutput) → COORD kernel32

Retrieves the size of the largest possible console window, based on the current font and the size of the display. [...]

GetLastError() → int kernel32

Retrieves the calling thread's last-error code value. The last-error code is maintained on a per-thread basis. Multiple threads do not overwrite each other's last-error code. [...]

GetLocaleInfoEx(Pointer<Utf16> lpLocaleName, int LCType, Pointer<Utf16> lpLCData, int cchData) → int kernel32

Retrieves information about a locale specified by name. [...]

GetLocalTime(Pointer<SYSTEMTIME> lpSystemTime) → void kernel32

Retrieves the current local date and time. [...]

GetLogicalDriveStrings(int nBufferLength, Pointer<Utf16> lpBuffer) → int kernel32

Fills a buffer with strings that specify valid drives in the system. [...]

GetModuleFileName(int hModule, Pointer<Utf16> lpFilename, int nSize) → int kernel32

Retrieves the fully qualified path for the file that contains the specified module. The module must have been loaded by the current process. [...]

GetModuleHandle(Pointer<Utf16> lpModuleName) → int kernel32

Retrieves a module handle for the specified module. The module must have been loaded by the calling process. [...]

GetNativeSystemInfo(Pointer<SYSTEM_INFO> lpSystemInfo) → void kernel32

Retrieves information about the current system to an application running under WOW64. If the function is called from a 64-bit application, or on a 64-bit system that does not have an Intel64 or x64 processor (such as ARM64), it is equivalent to the GetSystemInfo function. [...]

GetPhysicallyInstalledSystemMemory(Pointer<Uint64> TotalMemoryInKilobytes) → int kernel32

Retrieves the amount of RAM that is physically installed on the computer. [...]

GetProcAddress(int hModule, Pointer<Uint8> lpProcName) → int kernel32

Retrieves the address of an exported function or variable from the specified dynamic-link library (DLL). [...]

GetProcessHeap() → int kernel32

Retrieves a handle to the default heap of the calling process. This handle can then be used in subsequent calls to the heap functions. [...]

GetProductInfo(int dwOSMajorVersion, int dwOSMinorVersion, int dwSpMajorVersion, int dwSpMinorVersion, Pointer<Uint32> pdwReturnedProductType) → int kernel32

Retrieves the product type for the operating system on the local computer, and maps the type to the product types supported by the specified operating system. [...]

GetStdHandle(int nStdHandle) → int kernel32

Retrieves a handle to the specified standard device (standard input, standard output, or standard error). [...]

GetSystemDefaultLangID() → int kernel32

Returns the language identifier for the system locale. [...]

GetSystemDefaultLocaleName(Pointer<Utf16> lpLocaleName, int cchLocaleName) → int kernel32

Retrieves the system default locale name. [...]

GetSystemDirectory(Pointer<Utf16> lpBuffer, int uSize) → int kernel32

Retrieves the path of the system directory. The system directory contains system files such as dynamic-link libraries and drivers. [...]

GetSystemInfo(Pointer<SYSTEM_INFO> lpSystemInfo) → void kernel32

Retrieves information about the current system. To retrieve accurate information for an application running on WOW64, call the GetNativeSystemInfo function. [...]

GetSystemPowerStatus(Pointer<SYSTEM_POWER_STATUS> lpSystemPowerStatus) → int kernel32

Retrieves the power status of the system. The status indicates whether the system is running on AC or DC power, whether the battery is currently charging, how much battery life remains, and if battery saver is on or off. [...]

GetSystemTime(Pointer<SYSTEMTIME> lpSystemTime) → void kernel32

Retrieves the current local date and time. [...]

GetTempPath(int nBufferLength, Pointer<Utf16> lpBuffer) → int kernel32

Retrieves the path of the directory designated for temporary files. [...]

GetThreadLocale() → int kernel32

Returns the locale identifier of the current locale for the calling thread. [...]

GetThreadUILanguage() → int kernel32

Returns the language identifier of the first user interface language for the current thread. [...]

GetUserDefaultLangID() → int kernel32

Returns the language identifier of the Region Format setting for the current user. [...]

GetUserDefaultLocaleName(Pointer<Utf16> lpLocaleName, int cchLocaleName) → int kernel32

Retrieves the user default locale name. [...]

GetVersionEx(Pointer<OSVERSIONINFO> lpVersionInformation) → int kernel32

With the release of Windows 8.1, the behavior of the GetVersionEx API has changed in the value it will return for the operating system version. The value returned by the GetVersionEx function now depends on how the application is manifested. Applications not manifested for Windows 8.1 or Windows 10 will return the Windows 8 OS version value (6.2). Once an application is manifested for a given operating system version, GetVersionEx will always return the version that the application is manifested for in future releases. [...]

GetVolumePathNamesForVolumeName(Pointer<Utf16> lpszVolumeName, Pointer<Utf16> lpszVolumePathNames, int cchBufferLength, Pointer<Uint32> lpcchReturnLength) → int kernel32

Retrieves a list of drive letters and mounted folder paths for the specified volume. [...]

GlobalAlloc(int uFlags, int dwBytes) → int kernel32

Allocates the specified number of bytes from the heap. [...]

GlobalFree(int hMem) → int kernel32

Frees the specified global memory object and invalidates its handle. [...]

GlobalLock(int hMem) → Pointer<NativeType> kernel32

Locks a global memory object and returns a pointer to the first byte of the object's memory block. [...]

GlobalUnlock(int hMem) → int kernel32

Decrements the lock count associated with a memory object that was allocated with GMEM_MOVEABLE. This function has no effect on memory objects allocated with GMEM_FIXED. [...]

HeapAlloc(int hHeap, int dwFlags, int dwBytes) → Pointer<NativeType> kernel32

Allocates a block of memory from a heap. The allocated memory is not movable. [...]

HeapFree(int hHeap, int dwFlags, Pointer<NativeType> lpMem) → int kernel32

Frees a memory block allocated from a heap by the HeapAlloc or HeapReAlloc function. [...]

InitializeProcThreadAttributeList(Pointer<NativeType> lpAttributeList, int dwAttributeCount, int dwFlags, Pointer<IntPtr> lpSize) → int kernel32

Initializes the specified list of attributes for process and thread creation. [...]

IsDebuggerPresent() → int kernel32

Determines whether the calling process is being debugged by a user-mode debugger. [...]

IsValidLocaleName(Pointer<Utf16> lpLocaleName) → int kernel32

Determines if the specified locale name is valid for a locale that is installed or supported on the operating system. [...]

IsWow64Process2(int hProcess, Pointer<Uint16> pProcessMachine, Pointer<Uint16> pNativeMachine) → int kernel32

Determines whether the specified process is running under WOW64. Also returns additional machine process and architecture information. [...]

LoadLibrary(Pointer<Utf16> lpLibFileName) → int kernel32

Loads the specified module into the address space of the calling process. The specified module may cause other modules to be loaded. [...]

LoadResource(int hModule, int hResInfo) → int kernel32

Retrieves a handle that can be used to obtain a pointer to the first byte of the specified resource in memory. [...]

LockResource(int hResData) → Pointer<NativeType> kernel32

Retrieves a pointer to the specified resource in memory. [...]

MoveFile(Pointer<Utf16> lpExistingFileName, Pointer<Utf16> lpNewFileName) → int kernel32

Moves an existing file or a directory, including its children. [...]

OpenProcess(int dwDesiredAccess, int bInheritHandle, int dwProcessId) → int kernel32

Opens an existing local process object. [...]

OutputDebugString(Pointer<Utf16> lpOutputString) → void kernel32

Sends a string to the debugger for display. [...]

QueryDosDevice(Pointer<Utf16> lpDeviceName, Pointer<Utf16> lpTargetPath, int ucchMax) → int kernel32

Retrieves information about MS-DOS device names. The function can obtain the current mapping for a particular MS-DOS device name. The function can also obtain a list of all existing MS-DOS device names. [...]

QueryPerformanceCounter(Pointer<Int64> lpPerformanceCount) → int kernel32

Retrieves the current value of the performance counter, which is a high resolution (<1us) time stamp that can be used for time-interval measurements. [...]

QueryPerformanceFrequency(Pointer<Int64> lpFrequency) → int kernel32

Retrieves the frequency of the performance counter. The frequency of the performance counter is fixed at system boot and is consistent across all processors. Therefore, the frequency need only be queried upon application initialization, and the result can be cached. [...]

ReadConsole(int hConsoleInput, Pointer<NativeType> lpBuffer, int nNumberOfCharsToRead, Pointer<Uint32> lpNumberOfCharsRead, Pointer<NativeType> pInputControl) → int kernel32

Reads character input from the console input buffer and removes it from the buffer. [...]

ReadFile(int hFile, Pointer<NativeType> lpBuffer, int nNumberOfBytesToRead, Pointer<Uint32> lpNumberOfBytesRead, Pointer<OVERLAPPED> lpOverlapped) → int kernel32

Reads data from the specified file or input/output (I/O) device. Reads occur at the position specified by the file pointer if supported by the device. [...]

ReadProcessMemory(int hProcess, Pointer<NativeType> lpBaseAddress, Pointer<NativeType> lpBuffer, int nSize, Pointer<IntPtr> lpNumberOfBytesRead) → int kernel32

ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. [...]

ReleaseActCtx(int hActCtx) → void kernel32

The ReleaseActCtx function decrements the reference count of the specified activation context. [...]

RemoveDirectory(Pointer<Utf16> lpPathName) → int kernel32

Deletes an existing empty directory. [...]

ResizePseudoConsole(int hPC, COORD size) → int kernel32

Resizes the internal buffers for a pseudoconsole to the given size. [...]

ScrollConsoleScreenBuffer(int hConsoleOutput, Pointer<SMALL_RECT> lpScrollRectangle, Pointer<SMALL_RECT> lpClipRectangle, COORD dwDestinationOrigin, Pointer<CHAR_INFO> lpFill) → int kernel32

Moves a block of data in a screen buffer. The effects of the move can be limited by specifying a clipping rectangle, so the contents of the console screen buffer outside the clipping rectangle are unchanged. [...]

SetConsoleCtrlHandler(Pointer<NativeFunction<HandlerProc>> HandlerRoutine, int Add) → int kernel32

Adds or removes an application-defined HandlerRoutine function from the list of handler functions for the calling process. [...]

SetConsoleCursorInfo(int hConsoleOutput, Pointer<CONSOLE_CURSOR_INFO> lpConsoleCursorInfo) → int kernel32

Sets the size and visibility of the cursor for the specified console screen buffer. [...]

SetConsoleCursorPosition(int hConsoleOutput, COORD dwCursorPosition) → int kernel32

Sets the cursor position in the specified console screen buffer. [...]

SetConsoleDisplayMode(int hConsoleOutput, int dwFlags, Pointer<COORD> lpNewScreenBufferDimensions) → int kernel32

Sets the display mode of the specified console screen buffer. [...]

SetConsoleMode(int hConsoleHandle, int dwMode) → int kernel32

Sets the input mode of a console's input buffer or the output mode of a console screen buffer. [...]

SetConsoleTextAttribute(int hConsoleOutput, int wAttributes) → int kernel32

Sets the attributes of characters written to the console screen buffer by the WriteFile or WriteConsole function, or echoed by the ReadFile or ReadConsole function. This function affects text written after the function call. [...]

SetConsoleWindowInfo(int hConsoleOutput, int bAbsolute, Pointer<SMALL_RECT> lpConsoleWindow) → int kernel32

Sets the current size and position of a console screen buffer's window. [...]

SetCurrentDirectory(Pointer<Utf16> lpPathName) → int kernel32

Changes the current directory for the current process. [...]

SetFilePointer(int hFile, int lDistanceToMove, Pointer<Int32> lpDistanceToMoveHigh, int dwMoveMethod) → int kernel32

Moves the file pointer of the specified file. [...]

SetFilePointerEx(int hFile, int liDistanceToMove, Pointer<Int64> lpNewFilePointer, int dwMoveMethod) → int kernel32

Moves the file pointer of the specified file. [...]

SetStdHandle(int nStdHandle, int hHandle) → int kernel32

Sets the handle for the specified standard device (standard input, standard output, or standard error). [...]

SetThreadExecutionState(int esFlags) → int kernel32

Enables an application to inform the system that it is in use, thereby preventing the system from entering sleep or turning off the display while the application is running. [...]

SetThreadUILanguage(int LangId) → int kernel32

Sets the user interface language for the current thread. [...]

Sleep(int dwMilliseconds) → void kernel32

Suspends the execution of the current thread until the time-out interval elapses. [...]

UpdateProcThreadAttribute(Pointer<NativeType> lpAttributeList, int dwFlags, int Attribute, Pointer<NativeType> lpValue, int cbSize, Pointer<NativeType> lpPreviousValue, Pointer<IntPtr> lpReturnSize) → int kernel32

Updates the specified attribute in a list of attributes for process and thread creation. [...]

UpdateResource(int hUpdate, Pointer<Utf16> lpType, Pointer<Utf16> lpName, int wLanguage, Pointer<NativeType> lpData, int cb) → int kernel32

Adds, deletes, or replaces a resource in a portable executable (PE) file. [...]

VirtualAlloc(Pointer<NativeType> lpAddress, int dwSize, int flAllocationType, int flProtect) → Pointer<NativeType> kernel32

Reserves, commits, or changes the state of a region of pages in the virtual address space of the calling process. Memory allocated by this function is automatically initialized to zero. [...]

VirtualFree(Pointer<NativeType> lpAddress, int dwSize, int dwFreeType) → int kernel32

Releases, decommits, or releases and decommits a region of pages within the virtual address space of the calling process. [...]

WaitForSingleObject(int hHandle, int dwMilliseconds) → int kernel32

Waits until the specified object is in the signaled state or the time-out interval elapses. [...]

WideCharToMultiByte(int CodePage, int dwFlags, Pointer<Utf16> lpWideCharStr, int cchWideChar, Pointer<Uint8> lpMultiByteStr, int cbMultiByte, Pointer<Uint8> lpDefaultChar, Pointer<Uint32> lpUsedDefaultChar) → int kernel32

Maps a UTF-16 (wide character) string to a new character string. The new character string is not necessarily from a multibyte character set. [...]

Wow64SuspendThread(int hThread) → int kernel32

Suspends the specified WOW64 thread. [...]

WriteConsole(int hConsoleOutput, Pointer<NativeType> lpBuffer, int nNumberOfCharsToWrite, Pointer<Uint32> lpNumberOfCharsWritten, Pointer<NativeType> lpReserved) → int kernel32

Writes a character string to a console screen buffer beginning at the current cursor location. [...]

WriteFile(int hFile, Pointer<NativeType> lpBuffer, int nNumberOfBytesToWrite, Pointer<Uint32> lpNumberOfBytesWritten, Pointer<OVERLAPPED> lpOverlapped) → int kernel32

Writes data to the specified file or input/output (I/O) device. [...]

WriteProcessMemory(int hProcess, Pointer<NativeType> lpBaseAddress, Pointer<NativeType> lpBuffer, int nSize, Pointer<IntPtr> lpNumberOfBytesWritten) → int kernel32

Writes data to an area of memory in a specified process. The entire area to be written to must be accessible or the operation fails. [...]