kernel32 Topic

Windows Kernel APIs

The Win32 base APIs, such as memory management, input/output (I/O) operations, process and thread creation, and synchronization functions.

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. [...]
BuildCommDCB(Pointer<Utf16> lpDef, Pointer<DCB> lpDCB) int kernel32
Fills a specified DCB structure with values specified in a device-control string. The device-control string uses the syntax of the mode command. [...]
BuildCommDCBAndTimeouts(Pointer<Utf16> lpDef, Pointer<DCB> lpDCB, Pointer<COMMTIMEOUTS> lpCommTimeouts) int kernel32
Translates a device-definition string into appropriate device-control block codes and places them into a device control block. The function can also set up time-out values, including the possibility of no time-outs, for a device; the function's behavior in this regard depends on the contents of the device-definition string. [...]
CallNamedPipe(Pointer<Utf16> lpNamedPipeName, Pointer<NativeType> lpInBuffer, int nInBufferSize, Pointer<NativeType> lpOutBuffer, int nOutBufferSize, Pointer<Uint32> lpBytesRead, int nTimeOut) int kernel32
Connects to a message-type pipe (and waits if an instance of the pipe is not available), writes to and reads from the pipe, and then closes the pipe. [...]
CancelIo(int hFile) int kernel32
Cancels all pending input and output (I/O) operations that are issued by the calling thread for the specified file. The function does not cancel I/O operations that other threads issue for a file handle. [...]
CancelIoEx(int hFile, Pointer<OVERLAPPED> lpOverlapped) int kernel32
Marks any outstanding I/O operations for the specified file handle. The function only cancels I/O operations in the current process, regardless of which thread created the I/O operation. [...]
CancelSynchronousIo(int hThread) int kernel32
Marks pending synchronous I/O operations that are issued by the specified thread as canceled. [...]
CheckRemoteDebuggerPresent(int hProcess, Pointer<Int32> pbDebuggerPresent) int kernel32
Determines whether the specified process is being debugged. [...]
ClearCommBreak(int hFile) int kernel32
Restores character transmission for a specified communications device and places the transmission line in a nonbreak state. [...]
ClearCommError(int hFile, Pointer<Uint32> lpErrors, Pointer<COMSTAT> lpStat) int kernel32
Retrieves information about a communications error and reports the current status of a communications device. The function is called when a communications error occurs, and it clears the device's error flag to enable additional input and output (I/O) operations. [...]
CloseHandle(int hObject) int kernel32
Closes an open object handle. [...]
ClosePseudoConsole(int hPC) → void kernel32
Closes a pseudoconsole from the given handle. [...]
CommConfigDialog(Pointer<Utf16> lpszName, int hWnd, Pointer<COMMCONFIG> lpCC) int kernel32
Displays a driver-supplied configuration dialog box. [...]
CompareObjectHandles(int hFirstObjectHandle, int hSecondObjectHandle) int kernel32
Compares two object handles to determine if they refer to the same underlying kernel object. [...]
ConnectNamedPipe(int hNamedPipe, Pointer<OVERLAPPED> lpOverlapped) int kernel32
Enables a named pipe server process to wait for a client process to connect to an instance of a named pipe. A client process connects by calling either the CreateFile or CallNamedPipe function. [...]
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. [...]
CreateEvent(Pointer<SECURITY_ATTRIBUTES> lpEventAttributes, int bManualReset, int bInitialState, Pointer<Utf16> lpName) int kernel32
Creates or opens a named or unnamed event object. [...]
CreateEventEx(Pointer<SECURITY_ATTRIBUTES> lpEventAttributes, Pointer<Utf16> lpName, int dwFlags, int dwDesiredAccess) int kernel32
Creates or opens a named or unnamed event object and returns a handle to the object. [...]
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. [...]
CreateIoCompletionPort(int FileHandle, int ExistingCompletionPort, int CompletionKey, int NumberOfConcurrentThreads) int kernel32
Creates an input/output (I/O) completion port and associates it with a specified file handle, or creates an I/O completion port that is not yet associated with a file handle, allowing association at a later time. [...]
CreateNamedPipe(Pointer<Utf16> lpName, int dwOpenMode, int dwPipeMode, int nMaxInstances, int nOutBufferSize, int nInBufferSize, int nDefaultTimeOut, Pointer<SECURITY_ATTRIBUTES> lpSecurityAttributes) int kernel32
Creates an instance of a named pipe and returns a handle for subsequent pipe operations. A named pipe server process uses this function either to create the first instance of a specific named pipe and establish its basic attributes or to create a new instance of an existing named pipe. [...]
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. [...]
DeviceIoControl(int hDevice, int dwIoControlCode, Pointer<NativeType> lpInBuffer, int nInBufferSize, Pointer<NativeType> lpOutBuffer, int nOutBufferSize, Pointer<Uint32> lpBytesReturned, Pointer<OVERLAPPED> lpOverlapped) int kernel32
Sends a control code directly to a specified device driver, causing the corresponding device to perform the corresponding operation. [...]
DisconnectNamedPipe(int hNamedPipe) int kernel32
Disconnects the server end of a named pipe instance from a client process. [...]
DnsHostnameToComputerName(Pointer<Utf16> Hostname, Pointer<Utf16> ComputerName, Pointer<Uint32> nSize) int kernel32
Converts a DNS-style host name to a NetBIOS-style computer name. [...]
DosDateTimeToFileTime(int wFatDate, int wFatTime, Pointer<FILETIME> lpFileTime) int kernel32
Converts MS-DOS date and time values to a file time. [...]
DuplicateHandle(int hSourceProcessHandle, int hSourceHandle, int hTargetProcessHandle, Pointer<IntPtr> lpTargetHandle, int dwDesiredAccess, int bInheritHandle, int dwOptions) int kernel32
Duplicates an object handle. [...]
EndUpdateResource(int hUpdate, int fDiscard) int kernel32
Commits or discards changes made prior to a call to UpdateResource. [...]
EnumProcesses(Pointer<Uint32> lpidProcess, int cb, Pointer<Uint32> lpcbNeeded) int kernel32
Retrieves the process identifier for each process object in the system. [...]
EnumProcessModules(int hProcess, Pointer<IntPtr> lphModule, int cb, Pointer<Uint32> lpcbNeeded) int kernel32
Retrieves a handle for each module in the specified process. [...]
EnumProcessModulesEx(int hProcess, Pointer<IntPtr> lphModule, int cb, Pointer<Uint32> lpcbNeeded, int dwFilterFlag) int kernel32
Retrieves a handle for each module in the specified process that meets the specified filter criteria. [...]
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. [...]
EscapeCommFunction(int hFile, int dwFunc) int kernel32
Directs the specified communications device to perform an extended function. [...]
ExitProcess(int uExitCode) → void kernel32
Ends the calling process and all its threads. [...]
ExitThread(int dwExitCode) → void kernel32
Ends the calling thread. [...]
FileTimeToDosDateTime(Pointer<FILETIME> lpFileTime, Pointer<Uint16> lpFatDate, Pointer<Uint16> lpFatTime) int kernel32
Converts a file time to MS-DOS date and time values. [...]
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. [...]
FindPackagesByPackageFamily(Pointer<Utf16> packageFamilyName, int packageFilters, Pointer<Uint32> count, Pointer<Pointer<Utf16>> packageFullNames, Pointer<Uint32> bufferLength, Pointer<Utf16> buffer, Pointer<Uint32> packageProperties) int kernel32
Finds the packages with the specified family name for the current user. [...]
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<Pointer<Int8>> 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. [...]
GetActiveProcessorCount(int GroupNumber) int kernel32
Returns the number of active processors in a processor group or in the system. [...]
GetActiveProcessorGroupCount() int kernel32
Returns the number of active processor groups in the system. [...]
GetBinaryType(Pointer<Utf16> lpApplicationName, Pointer<Uint32> lpBinaryType) int kernel32
Determines whether a file is an executable (.exe) file, and if so, which subsystem runs the executable file. [...]
GetCommandLine() Pointer<Utf16> kernel32
Parses a Unicode command line string and returns an array of pointers to the command line arguments, along with a count of such arguments, in a way that is similar to the standard C run-time argv and argc values. [...]
GetCommConfig(int hCommDev, Pointer<COMMCONFIG> lpCC, Pointer<Uint32> lpdwSize) int kernel32
Retrieves the current configuration of a communications device. [...]
GetCommMask(int hFile, Pointer<Uint32> lpEvtMask) int kernel32
Retrieves the value of the event mask for a specified communications device. [...]
GetCommModemStatus(int hFile, Pointer<Uint32> lpModemStat) int kernel32
Retrieves the modem control-register values. [...]
GetCommPorts(Pointer<Uint32> lpPortNumbers, int uPortNumbersCount, Pointer<Uint32> puPortNumbersFound) int kernel32
Gets an array that contains the well-formed COM ports. [...]
GetCommProperties(int hFile, Pointer<COMMPROP> lpCommProp) int kernel32
Retrieves information about the communications properties for a specified communications device. [...]
GetCommState(int hFile, Pointer<DCB> lpDCB) int kernel32
Retrieves the current control settings for a specified communications device. [...]
GetCommTimeouts(int hFile, Pointer<COMMTIMEOUTS> lpCommTimeouts) int kernel32
Retrieves the time-out parameters for all read and write operations on a specified communications device. [...]
GetCompressedFileSize(Pointer<Utf16> lpFileName, Pointer<Uint32> lpFileSizeHigh) int kernel32
Retrieves the actual number of bytes of disk storage used to store a specified file. If the file is located on a volume that supports compression and the file is compressed, the value obtained is the compressed size of the specified file. If the file is located on a volume that supports sparse files and the file is a sparse file, the value obtained is the sparse size of the specified file. [...]
GetComputerName(Pointer<Utf16> lpBuffer, Pointer<Uint32> nSize) int kernel32
Retrieves the NetBIOS name of the local computer. This name is established at system startup, when the system reads it from the registry. [...]
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. [...]
GetCurrentProcessId() int kernel32
Retrieves the process identifier of the calling process. [...]
GetCurrentProcessorNumber() int kernel32
Retrieves the number of the processor the current thread was running on during the call to this function. [...]
GetCurrentThread() int kernel32
Retrieves a pseudo handle for the calling thread. [...]
GetCurrentThreadId() int kernel32
Retrieves the thread identifier of the calling thread. [...]
GetDefaultCommConfig(Pointer<Utf16> lpszName, Pointer<COMMCONFIG> lpCC, Pointer<Uint32> lpdwSize) int kernel32
Retrieves the default configuration for the specified communications device. [...]
GetDiskFreeSpace(Pointer<Utf16> lpRootPathName, Pointer<Uint32> lpSectorsPerCluster, Pointer<Uint32> lpBytesPerSector, Pointer<Uint32> lpNumberOfFreeClusters, Pointer<Uint32> lpTotalNumberOfClusters) int kernel32
Retrieves information about the specified disk, including the amount of free space on the disk. [...]
GetDllDirectory(int nBufferLength, Pointer<Utf16> lpBuffer) int kernel32
Retrieves the application-specific portion of the search path used to locate DLLs for the application. [...]
GetDriveType(Pointer<Utf16> lpRootPathName) int kernel32
Determines whether a disk drive is a removable, fixed, CD-ROM, RAM disk, or network drive. [...]
GetExitCodeProcess(int hProcess, Pointer<Uint32> lpExitCode) int kernel32
Retrieves the termination status of the specified process. [...]
GetFileAttributes(Pointer<Utf16> lpFileName) int kernel32
Retrieves file system attributes for a specified file or directory. [...]
GetFileAttributesEx(Pointer<Utf16> lpFileName, int fInfoLevelId, Pointer<NativeType> lpFileInformation) int kernel32
Retrieves attributes for a specified file or directory. [...]
GetFileInformationByHandle(int hFile, Pointer<BY_HANDLE_FILE_INFORMATION> lpFileInformation) int kernel32
Retrieves file information for the specified file. [...]
GetFileSize(int hFile, Pointer<Uint32> lpFileSizeHigh) int kernel32
Retrieves the size of the specified file, in bytes. It is recommended that you use GetFileSizeEx. [...]
GetFileSizeEx(int hFile, Pointer<Int64> lpFileSize) int kernel32
Retrieves the size of the specified file. [...]
GetFileType(int hFile) int kernel32
Retrieves the file type of the specified file. [...]
GetFinalPathNameByHandle(int hFile, Pointer<Utf16> lpszFilePath, int cchFilePath, int dwFlags) int kernel32
Retrieves the final path for the specified file. [...]
GetFullPathName(Pointer<Utf16> lpFileName, int nBufferLength, Pointer<Utf16> lpBuffer, Pointer<Pointer<Utf16>> lpFilePart) int kernel32
Retrieves the full path and file name of the specified file. [...]
GetHandleInformation(int hObject, Pointer<Uint32> lpdwFlags) int kernel32
Retrieves certain properties of an object handle. [...]
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. [...]
GetLogicalDrives() int kernel32
Retrieves a bitmask representing the currently available disk drives. [...]
GetLogicalDriveStrings(int nBufferLength, Pointer<Utf16> lpBuffer) int kernel32
Fills a buffer with strings that specify valid drives in the system. [...]
GetMaximumProcessorCount(int GroupNumber) int kernel32
Returns the maximum number of logical processors that a processor group or the system can have. [...]
GetMaximumProcessorGroupCount() int kernel32
Returns the maximum number of processor groups that the system can have. [...]
GetModuleBaseName(int hProcess, int hModule, Pointer<Utf16> lpBaseName, int nSize) int kernel32
Retrieves the base name of the specified module. [...]
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. [...]
GetModuleFileNameEx(int hProcess, int hModule, Pointer<Utf16> lpFilename, int nSize) int kernel32
Retrieves the fully qualified path for the file containing the specified module. [...]
GetModuleHandle(Pointer<Utf16> lpModuleName) int kernel32
Retrieves a module handle for the specified module. The module must have been loaded by the calling process. [...]
GetNamedPipeClientComputerName(int Pipe, Pointer<Utf16> ClientComputerName, int ClientComputerNameLength) int kernel32
Retrieves the client computer name for the specified named pipe. [...]
GetNamedPipeClientProcessId(int Pipe, Pointer<Uint32> ClientProcessId) int kernel32
Retrieves the client process identifier for the specified named pipe. [...]
GetNamedPipeClientSessionId(int Pipe, Pointer<Uint32> ClientSessionId) int kernel32
Retrieves the client process identifier for the specified named pipe. [...]
GetNamedPipeHandleState(int hNamedPipe, Pointer<Uint32> lpState, Pointer<Uint32> lpCurInstances, Pointer<Uint32> lpMaxCollectionCount, Pointer<Uint32> lpCollectDataTimeout, Pointer<Utf16> lpUserName, int nMaxUserNameSize) int kernel32
Retrieves information about a specified named pipe. The information returned can vary during the lifetime of an instance of the named pipe. [...]
GetNamedPipeInfo(int hNamedPipe, Pointer<Uint32> lpFlags, Pointer<Uint32> lpOutBufferSize, Pointer<Uint32> lpInBufferSize, Pointer<Uint32> lpMaxInstances) int kernel32
Retrieves information about the specified named pipe. [...]
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. [...]
GetOverlappedResult(int hFile, Pointer<OVERLAPPED> lpOverlapped, Pointer<Uint32> lpNumberOfBytesTransferred, int bWait) int kernel32
Retrieves the results of an overlapped operation on the specified file, named pipe, or communications device. To specify a timeout interval or wait on an alertable thread, use GetOverlappedResultEx. [...]
GetOverlappedResultEx(int hFile, Pointer<OVERLAPPED> lpOverlapped, Pointer<Uint32> lpNumberOfBytesTransferred, int dwMilliseconds, int bAlertable) int kernel32
Retrieves the results of an overlapped operation on the specified file, named pipe, or communications device within the specified time-out interval. The calling thread can perform an alertable wait. [...]
GetPhysicallyInstalledSystemMemory(Pointer<Uint64> TotalMemoryInKilobytes) int kernel32
Retrieves the amount of RAM that is physically installed on the computer. [...]
GetProcAddress(int hModule, Pointer<Utf8> 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. [...]
GetProcessHeaps(int NumberOfHeaps, Pointer<IntPtr> ProcessHeaps) int kernel32
Returns the number of active heaps and retrieves handles to all of the active heaps for the calling process. [...]
GetProcessId(int Process) int kernel32
Retrieves the process identifier of the specified process. [...]
GetProcessShutdownParameters(Pointer<Uint32> lpdwLevel, Pointer<Uint32> lpdwFlags) int kernel32
Retrieves the shutdown parameters for the currently calling process. [...]
GetProcessVersion(int ProcessId) int kernel32
Retrieves the major and minor version numbers of the system on which the specified process expects to run. [...]
GetProcessWorkingSetSize(int hProcess, Pointer<IntPtr> lpMinimumWorkingSetSize, Pointer<IntPtr> lpMaximumWorkingSetSize) int kernel32
Retrieves the minimum and maximum working set sizes of the specified process. [...]
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. [...]
GetQueuedCompletionStatus(int CompletionPort, Pointer<Uint32> lpNumberOfBytesTransferred, Pointer<IntPtr> lpCompletionKey, Pointer<Pointer<OVERLAPPED>> lpOverlapped, int dwMilliseconds) int kernel32
Attempts to dequeue an I/O completion packet from the specified I/O completion port. If there is no completion packet queued, the function waits for a pending I/O operation associated with the completion port to complete. [...]
GetQueuedCompletionStatusEx(int CompletionPort, Pointer<OVERLAPPED_ENTRY> lpCompletionPortEntries, int ulCount, Pointer<Uint32> ulNumEntriesRemoved, int dwMilliseconds, int fAlertable) int kernel32
Retrieves multiple completion port entries simultaneously. It waits for pending I/O operations that are associated with the specified completion port to complete. [...]
GetStartupInfo(Pointer<STARTUPINFO> lpStartupInfo) → void kernel32
Retrieves the contents of the STARTUPINFO structure that was specified when the calling process was created. [...]
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. [...]
GetSystemTimes(Pointer<FILETIME> lpIdleTime, Pointer<FILETIME> lpKernelTime, Pointer<FILETIME> lpUserTime) int kernel32
Retrieves system timing information. On a multiprocessor system, the values returned are the sum of the designated times across all processors. [...]
GetTempPath(int nBufferLength, Pointer<Utf16> lpBuffer) int kernel32
Retrieves the path of the directory designated for temporary files. [...]
GetThreadId(int Thread) int kernel32
Retrieves the thread identifier of the specified thread. [...]
GetThreadLocale() int kernel32
Returns the locale identifier of the current locale for the calling thread. [...]
GetThreadTimes(int hThread, Pointer<FILETIME> lpCreationTime, Pointer<FILETIME> lpExitTime, Pointer<FILETIME> lpKernelTime, Pointer<FILETIME> lpUserTime) int kernel32
Retrieves timing information for the specified 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. [...]
GetUserDefaultLCID() int kernel32
Returns the locale identifier for the user default locale. [...]
GetUserDefaultLocaleName(Pointer<Utf16> lpLocaleName, int cchLocaleName) int kernel32
Retrieves the user default locale name. [...]
GetVersionEx(Pointer<OSVERSIONINFO> lpVersionInformation) int kernel32
Gets information about the operating system version. [...]
GetVolumePathName(Pointer<Utf16> lpszFileName, Pointer<Utf16> lpszVolumePathName, int cchBufferLength) int kernel32
Retrieves the volume mount point where the specified path is mounted. [...]
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. [...]
GlobalSize(int hMem) int kernel32
Retrieves the current size of the specified global memory object, in bytes. [...]
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. [...]
HeapCompact(int hHeap, int dwFlags) int kernel32
Returns the size of the largest committed free block in the specified heap. If the Disable heap coalesce on free global flag is set, this function also coalesces adjacent free blocks of memory in the heap. [...]
HeapCreate(int flOptions, int dwInitialSize, int dwMaximumSize) int kernel32
Creates a private heap object that can be used by the calling process. The function reserves space in the virtual address space of the process and allocates physical storage for a specified initial portion of this block. [...]
HeapDestroy(int hHeap) int kernel32
Destroys the specified heap object. It decommits and releases all the pages of a private heap object, and it invalidates the handle to the heap. [...]
HeapFree(int hHeap, int dwFlags, Pointer<NativeType> lpMem) int kernel32
Frees a memory block allocated from a heap by the HeapAlloc or HeapReAlloc function. [...]
HeapLock(int hHeap) int kernel32
Attempts to acquire the critical section object, or lock, that is associated with a specified heap. [...]
HeapQueryInformation(int HeapHandle, int HeapInformationClass, Pointer<NativeType> HeapInformation, int HeapInformationLength, Pointer<IntPtr> ReturnLength) int kernel32
Retrieves information about the specified heap. [...]
HeapReAlloc(int hHeap, int dwFlags, Pointer<NativeType> lpMem, int dwBytes) Pointer<NativeType> kernel32
Retrieves information about the specified heap. [...]
HeapSetInformation(int HeapHandle, int HeapInformationClass, Pointer<NativeType> HeapInformation, int HeapInformationLength) int kernel32
Enables features for a specified heap. [...]
HeapSize(int hHeap, int dwFlags, Pointer<NativeType> lpMem) int kernel32
Retrieves the size of a memory block allocated from a heap by the HeapAlloc or HeapReAlloc function. [...]
HeapUnlock(int hHeap) int kernel32
Releases ownership of the critical section object, or lock, that is associated with a specified heap. It reverses the action of the HeapLock function. [...]
HeapValidate(int hHeap, int dwFlags, Pointer<NativeType> lpMem) int kernel32
Validates the specified heap. The function scans all the memory blocks in the heap and verifies that the heap control structures maintained by the heap manager are in a consistent state. You can also use the HeapValidate function to validate a single memory block within a specified heap without checking the validity of the entire heap. [...]
HeapWalk(int hHeap, Pointer<PROCESS_HEAP_ENTRY> lpEntry) int kernel32
Enumerates the memory blocks in the specified heap. [...]
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. [...]
IsNativeVhdBoot(Pointer<Int32> NativeVhdBoot) int kernel32
Indicates if the OS was booted from a VHD container. [...]
IsSystemResumeAutomatic() int kernel32
Determines the current state of the computer. [...]
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. [...]
LocalFree(int hMem) int kernel32
Frees the specified local memory object and invalidates its handle. [...]
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. [...]
OpenCommPort(int uPortNumber, int dwDesiredAccess, int dwFlagsAndAttributes) int kernel32
Attempts to open a communication device. [...]
OpenEvent(int dwDesiredAccess, int bInheritHandle, Pointer<Utf16> lpName) int kernel32
Opens an existing named event object. [...]
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. [...]
PackageFamilyNameFromFullName(Pointer<Utf16> packageFullName, Pointer<Uint32> packageFamilyNameLength, Pointer<Utf16> packageFamilyName) int kernel32
Gets the package family name for the specified package full name. [...]
PeekNamedPipe(int hNamedPipe, Pointer<NativeType> lpBuffer, int nBufferSize, Pointer<Uint32> lpBytesRead, Pointer<Uint32> lpTotalBytesAvail, Pointer<Uint32> lpBytesLeftThisMessage) int kernel32
Copies data from a named or anonymous pipe into a buffer without removing it from the pipe. It also returns information about data in the pipe. [...]
PostQueuedCompletionStatus(int CompletionPort, int dwNumberOfBytesTransferred, int dwCompletionKey, Pointer<OVERLAPPED> lpOverlapped) int kernel32
Posts an I/O completion packet to an I/O completion port. [...]
PurgeComm(int hFile, int dwFlags) int kernel32
Discards all characters from the output or input buffer of a specified communications resource. It can also terminate pending read or write operations on the resource. [...]
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<Void> 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. [...]
ReOpenFile(int hOriginalFile, int dwDesiredAccess, int dwShareMode, int dwFlagsAndAttributes) int kernel32
Reopens the specified file system object with different access rights, sharing mode, and flags. [...]
ResetEvent(int hEvent) int kernel32
Sets the specified event object to the nonsignaled state. [...]
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. [...]
SetCommBreak(int hFile) int kernel32
Suspends character transmission for a specified communications device and places the transmission line in a break state until the ClearCommBreak function is called. [...]
SetCommConfig(int hCommDev, Pointer<COMMCONFIG> lpCC, int dwSize) int kernel32
Sets the current configuration of a communications device. [...]
SetCommMask(int hFile, int dwEvtMask) int kernel32
Specifies a set of events to be monitored for a communications device. [...]
SetCommState(int hFile, Pointer<DCB> lpDCB) int kernel32
Configures a communications device according to the specifications in a device-control block (a DCB structure). The function reinitializes all hardware and control settings, but it does not empty output or input queues. [...]
SetCommTimeouts(int hFile, Pointer<COMMTIMEOUTS> lpCommTimeouts) int kernel32
Sets the time-out parameters for all read and write operations on a specified communications device. [...]
SetConsoleCtrlHandler(Pointer<NativeFunction<HandlerRoutine>> 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. [...]
SetDefaultCommConfig(Pointer<Utf16> lpszName, Pointer<COMMCONFIG> lpCC, int dwSize) int kernel32
Sets the default configuration for a communications device. [...]
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. [...]
SetFileShortName(int hFile, Pointer<Utf16> lpShortName) int kernel32
Sets the short name for the specified file. The file must be on an NTFS file system volume. [...]
SetFirmwareEnvironmentVariable(Pointer<Utf16> lpName, Pointer<Utf16> lpGuid, Pointer<NativeType> pValue, int nSize) int kernel32
Sets the value of the specified firmware environment variable. [...]
SetFirmwareEnvironmentVariableEx(Pointer<Utf16> lpName, Pointer<Utf16> lpGuid, Pointer<NativeType> pValue, int nSize, int dwAttributes) int kernel32
Sets the value of the specified firmware environment variable and the attributes that indicate how this variable is stored and maintained. [...]
SetHandleInformation(int hObject, int dwMask, int dwFlags) int kernel32
Sets certain properties of an object handle. [...]
SetNamedPipeHandleState(int hNamedPipe, Pointer<Uint32> lpMode, Pointer<Uint32> lpMaxCollectionCount, Pointer<Uint32> lpCollectDataTimeout) int kernel32
Sets the read mode and the blocking mode of the specified named pipe. If the specified handle is to the client end of a named pipe and if the named pipe server process is on a remote computer, the function can also be used to control local buffering. [...]
SetProcessAffinityMask(int hProcess, int dwProcessAffinityMask) int kernel32
Sets a processor affinity mask for the threads of the specified process. [...]
SetProcessPriorityBoost(int hProcess, int bDisablePriorityBoost) int kernel32
Disables or enables the ability of the system to temporarily boost the priority of the threads of the specified process. [...]
SetProcessWorkingSetSize(int hProcess, int dwMinimumWorkingSetSize, int dwMaximumWorkingSetSize) int kernel32
Sets the minimum and maximum working set sizes for the specified process. [...]
SetStdHandle(int nStdHandle, int hHandle) int kernel32
Sets the handle for the specified standard device (standard input, standard output, or standard error). [...]
SetThreadAffinityMask(int hThread, int dwThreadAffinityMask) int kernel32
Sets a processor affinity mask for the specified thread. [...]
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. [...]
SetupComm(int hFile, int dwInQueue, int dwOutQueue) int kernel32
Initializes the communications parameters for a specified communications device. [...]
SetVolumeLabel(Pointer<Utf16> lpRootPathName, Pointer<Utf16> lpVolumeName) int kernel32
Sets the label of a file system volume. [...]
Sleep(int dwMilliseconds) → void kernel32
Suspends the execution of the current thread until the time-out interval elapses. [...]
SleepEx(int dwMilliseconds, int bAlertable) int kernel32
Suspends the current thread until the specified condition is met. Execution resumes when one of the following occurs: (i) an I/O completion callback function is called; (ii) an asynchronous procedure call (APC) is queued to the thread; (iii) the time-out interval elapses. [...]
TerminateProcess(int hProcess, int uExitCode) int kernel32
Terminates the specified process and all of its threads. [...]
TerminateThread(int hThread, int dwExitCode) int kernel32
Terminates a thread. [...]
TransactNamedPipe(int hNamedPipe, Pointer<NativeType> lpInBuffer, int nInBufferSize, Pointer<NativeType> lpOutBuffer, int nOutBufferSize, Pointer<Uint32> lpBytesRead, Pointer<OVERLAPPED> lpOverlapped) int kernel32
Combines the functions that write a message to and read a message from the specified named pipe into a single network operation. [...]
TransmitCommChar(int hFile, int cChar) int kernel32
Transmits a specified character ahead of any pending data in the output buffer of the specified communications device. [...]
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. [...]
VerLanguageName(int wLang, Pointer<Utf16> szLang, int cchLang) int kernel32
Retrieves a description string for the language associated with a specified binary Microsoft language identifier. [...]
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. [...]
VirtualAllocEx(int hProcess, Pointer<NativeType> lpAddress, int dwSize, int flAllocationType, int flProtect) Pointer<NativeType> kernel32
Reserves, commits, or changes the state of a region of memory within the virtual address space of a specified process. The function initializes the memory it allocates 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. [...]
VirtualFreeEx(int hProcess, Pointer<NativeType> lpAddress, int dwSize, int dwFreeType) int kernel32
Releases, decommits, or releases and decommits a region of memory within the virtual address space of a specified process. [...]
VirtualLock(Pointer<NativeType> lpAddress, int dwSize) int kernel32
Locks the specified region of the process's virtual address space into physical memory, ensuring that subsequent access to the region will not incur a page fault. [...]
VirtualUnlock(Pointer<NativeType> lpAddress, int dwSize) int kernel32
Unlocks a specified range of pages in the virtual address space of a process, enabling the system to swap the pages out to the paging file if necessary. [...]
WaitCommEvent(int hFile, Pointer<Uint32> lpEvtMask, Pointer<OVERLAPPED> lpOverlapped) int kernel32
Waits for an event to occur for a specified communications device. The set of events that are monitored by this function is contained in the event mask associated with the device handle. [...]
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<Utf8> lpMultiByteStr, int cbMultiByte, Pointer<Utf8> lpDefaultChar, Pointer<Int32> 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. [...]