public Interface Kernel32

The pipe name.

The data to be written to the pipe.

The size of the write buffer, in bytes.

The buffer that receives the data read from the pipe.

The size of the read buffer, in bytes.

A variable that receives the number of bytes read from the pipe.

The number of milliseconds to wait for the named pipe to be available.

A handle to the server end of a named pipe instance.

A pointer to an WinBase.OVERLAPPED structure.

Pointer to a null-terminated string that specifies the path of the directory to be created.

Pointer to a SECURITY_ATTRIBUTES structure. The lpSecurityDescriptor member of the structure specifies a security descriptor for the new directory. If lpSecurityAttributes is NULL, the directory gets a default security descriptor.

A pointer to a null-terminated string that specifies the name of an object to create or open.

The access to the object, which can be read, write, or both.

The sharing mode of an object, which can be read, write, both, or none.

A pointer to a SECURITY_ATTRIBUTES structure that determines whether or not the returned handle can be inherited by child processes. If lpSecurityAttributes is NULL, the handle cannot be inherited.

An action to take on files that exist and do not exist.

The file attributes and flags.

Handle to a template file with the GENERIC_READ access right. The template file supplies file attributes and extended attributes for the file that is being created. This parameter can be NULL.

An open file handle or INVALID_HANDLE_VALUE.

A handle to an existing I/O completion port or NULL.

The per-handle user-defined completion key that is included in every I/O completion packet for the specified file handle.

The maximum number of threads that the operating system can allow to concurrently process I/O completion packets for the I/O completion port.

The unique pipe name. This string must have the following form:

\\.\pipe\pipename

The pipename part of the name can include any character other than a backslash, including numbers and special characters. The entire pipe name string can be up to MAX_PIPE_NAME_LENGTH characters long. Pipe names are not case sensitive.

The open mode. The function fails if specifies anything other than 0 or the allowed flags

The pipe mode. The function fails if specifies anything other than 0 or the allowed flags

The maximum number of instances that can be created for this pipe. Acceptable values are in the range 1 through PIPE_UNLIMITED_INSTANCES

The number of bytes to reserve for the output buffer.

The number of bytes to reserve for the input buffer.

The default time-out value, in milliseconds. A value of zero will result in a default time-out of 50 milliseconds

A pointer to a WinBase.SECURITY_ATTRIBUTES structure that specifies a security descriptor for the new named pipe. If null the named pipe gets a default security descriptor and the handle cannot be inherited.

The name of the module to be executed.

The command line to be executed.

A pointer to a SECURITY_ATTRIBUTES structure that determines whether the returned handle to the new process object can be inherited by child processes. If lpProcessAttributes is NULL, the handle cannot be inherited.

A pointer to a SECURITY_ATTRIBUTES structure that determines whether the returned handle to the new thread object can be inherited by child processes. If lpThreadAttributes is NULL, the handle cannot be inherited.

If this parameter TRUE, each inheritable handle in the calling process is inherited by the new process. If the parameter is FALSE, the handles are not inherited. Note that inherited handles have the same value and access rights as the original handles.

The flags that control the priority class and the creation of the process.

A pointer to the environment block for the new process. If this parameter is NULL, the new process uses the environment of the calling process.

The full path to the current directory for the process.

A pointer to a STARTUPINFO or STARTUPINFOEX structure.

A pointer to a PROCESS_INFORMATION structure that receives identification information about the new process.

The portions of the system to be included in the snapshot.

The process identifier of the process to be included in the snapshot. This parameter can be zero to indicate the current process. This parameter is used when the TH32CS_SNAPHEAPLIST, TH32CS_SNAPMODULE, TH32CS_SNAPMODULE32, or TH32CS_SNAPALL value is specified. Otherwise, it is ignored and all processes are included in the snapshot. If the specified process is the Idle process or one of the CSRSS processes, this function fails and the last error code is ERROR_ACCESS_DENIED because their access restrictions prevent user-level code from opening them. If the specified process is a 64-bit process and the caller is a 32-bit process, this function fails and the last error code is ERROR_PARTIAL_COPY (299).

The name of the file to be deleted.

A handle to the device on which the operation is to be performed. The device is typically a volume, directory, file, or stream. To retrieve a device handle, use the CreateFile function. For more information, see Remarks.

The control code for the operation. This value identifies the specific operation to be performed and the type of device on which to perform it. For a list of the control codes, see Remarks. The documentation for each control code provides usage details for the lpInBuffer, nInBufferSize, lpOutBuffer, and nOutBufferSize parameters.

A pointer to the input buffer that contains the data required to perform the operation. The format of this data depends on the value of the dwIoControlCode parameter. This parameter can be NULL if dwIoControlCode specifies an operation that does not require input data.

The size of the input buffer, in bytes.

A pointer to the output buffer that is to receive the data returned by the operation. The format of this data depends on the value of the dwIoControlCode parameter. This parameter can be NULL if dwIoControlCode specifies an operation that does not return data.

The size of the output buffer, in bytes.

A pointer to a variable that receives the size of the data stored in the output buffer, in bytes. If the output buffer is too small to receive any data, the call fails, GetLastError returns ERROR_INSUFFICIENT_BUFFER, and lpBytesReturned is zero. If the output buffer is too small to hold all of the data but can hold some entries, some drivers will return as much data as fits. In this case, the call fails, GetLastError returns ERROR_MORE_DATA, and lpBytesReturned indicates the amount of data received. Your application should call DeviceIoControl again with the same operation, specifying a new starting point. If lpOverlapped is NULL, lpBytesReturned cannot be NULL. Even when an operation returns no output data and lpOutBuffer is NULL, DeviceIoControl makes use of lpBytesReturned. After such an operation, the value of lpBytesReturned is meaningless. If lpOverlapped is not NULL, lpBytesReturned can be NULL. If this parameter is not NULL and the operation returns data, lpBytesReturned is meaningless until the overlapped operation has completed. To retrieve the number of bytes returned, call GetOverlappedResult. If hDevice is associated with an I/O completion port, you can retrieve the number of bytes returned by calling GetQueuedCompletionStatus.

A pointer to an OVERLAPPED structure. If hDevice was opened without specifying FILE_FLAG_OVERLAPPED, lpOverlapped is ignored. If hDevice was opened with the FILE_FLAG_OVERLAPPED flag, the operation is performed as an overlapped (asynchronous) operation. In this case, lpOverlapped must point to a valid OVERLAPPED structure that contains a handle to an event object. Otherwise, the function fails in unpredictable ways. For overlapped operations, DeviceIoControl returns immediately, and the event object is signaled when the operation has been completed. Otherwise, the function does not return until the operation has been completed or an error occurs.

Handle to the process with the handle to duplicate. The handle must have the PROCESS_DUP_HANDLE access right.

Handle to duplicate. This is an open object handle that is valid in the context of the source process.

Handle to the process that is to receive the duplicated handle. The handle must have the PROCESS_DUP_HANDLE access right.

Pointer to a variable that receives the duplicate handle. This handle value is valid in the context of the target process. If hSourceHandle is a pseudo handle returned by GetCurrentProcess or GetCurrentThread, DuplicateHandle converts it to a real handle to a process or thread, respectively.

Access requested for the new handle.

Indicates whether the handle is inheritable.

Optional actions.

A handle to a module to be searched.
This handle must be obtained through LoadLibrary or LoadLibraryEx.
See Remarks for more information. If this parameter is NULL, that is equivalent to passing in a handle to the module used to create the current process.

A pointer to the callback function to be called for each enumerated resource type.
For more information, see the EnumResTypeProc function.

An application-defined value passed to the callback function.

A buffer that contains one or more environment-variable strings in the form: %variableName%. For each such reference, the %variableName% portion is replaced with the current value of that environment variable.

Case is ignored when looking up the environment-variable name. If the name is not found, the %variableName% portion is left unexpanded.

Note that this function does not support all the features that Cmd.exe supports. For example, it does not support %variableName:str1=str2% or %variableName:~offset,length%.

A pointer to a buffer that receives the result of expanding the environment variable strings in the lpSrc buffer. Note that this buffer cannot be the same as the lpSrc buffer.

The maximum number of characters that can be stored in the buffer pointed to by the lpDst parameter. When using ANSI strings, the buffer size should be the string length, plus terminating null character, plus one. When using Unicode strings, the buffer size should be the string length plus the terminating null character.

[in] A pointer to a FILETIME structure containing the file time to be converted to system (UTC) date and time format. This value must be less than 0x8000000000000000. Otherwise, the function fails.

A pointer to a SYSTEMTIME structure to receive the converted file time.

The directory or path, and the file name. The file name can include wildcard characters, for example, an asterisk (*) or a question mark (?). This parameter should not be NULL, an invalid string (for example, an empty string or a string that is missing the terminating null character), or end in a trailing backslash (\). If the string ends with a wildcard, period, or directory name, the user must have access to the root and all subdirectories on the path. In the ANSI version of this function, the name is limited to MAX_PATH characters. To extend this limit to approximately 32,000 wide characters, call the Unicode version of the function (FindFirstFileExW), and prepend "\\?\" to the path. For more information, see Naming a File. Tip Starting in Windows 10, version 1607, for the unicode version of this function (FindFirstFileExW), you can opt-in to remove the MAX_PATH character limitation without prepending "\\?\". See the "Maximum Path Limitation" section of Naming Files, Paths, and Namespaces for details.

A pointer to the buffer that receives the file data. The pointer type is determined by the level of information that is specified in the fInfoLevelId parameter.

A buffer that receives a null-terminated string that specifies a volume GUID path for the first volume that is found

The length of the buffer to receive the volume GUID path

The search handle returned by a previous call to the FindFirstFile or FindFirstFileEx function.

A pointer to the WIN32_FIND_DATA structure that receives information about the found file or subdirectory.

A mounted folder search handle returned by a previous call to the FindFirstVolumeMountPoint(String, char[], int) function.

A buffer that receives the name of the (next) mounted folder that is found.

The length of the buffer that receives the path to the mounted folder

The volume search handle returned by a previous call to the FindFirstVolume(char[], int).

A handle to the open file. If a handle to a communications device, the function only flushes the transmit buffer. If a handle to the server end of a named pipe, the function does not return until the client has read all buffered data from the pipe.

A pointer to a block of environment strings obtained by calling the GetEnvironmentStrings() function

A handle to the process. This handle must have the PROCESS_VM_READ access right.

A pointer to a buffer that receives the restart command line specified by the application when it called the RegisterApplicationRestart function. The maximum size of the command line, in characters, is RESTART_MAX_CMD_LINE. Can be NULL if pcchSize is zero.

On input, specifies the size of the pwzCommandLine buffer, in characters.

If the buffer is not large enough to receive the command line, the function fails with HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) and sets this parameter to the required buffer size, in characters.

On output, specifies the size of the buffer that was used.

To determine the required buffer size, set pwzCommandLine to NULL and this parameter to zero. The size includes one for the null-terminator character. Note that the function returns S_OK, not HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) in this case.

A pointer to a variable that receives the flags specified by the application when it called the RegisterApplicationRestart function.

[in] A handle to the communications device. The com.sun.jna.platform.win32.Kernel32#CreateFile(String, int, int, com.sun.jna.platform.win32.WinBase.SECURITY_ATTRIBUTES, int, int, com.sun.jna.platform.win32.WinNT.HANDLE) function returns this handle.

[in] A pointer to a WinBase.COMMTIMEOUTS structure in which the time-out information is returned.

An enumeration value specifying the type of name to be retrieved - this parameter is a value from the COMPUTER_NAME_FORMAT in the WinBase definitions

A pointer to a buffer that receives the computer name or the cluster virtual server name. The length of the name may be greater than MAX_COMPUTERNAME_LENGTH characters because DNS allows longer names. To ensure that this buffer is large enough, set this parameter to NULL and use the required buffer size returned in the lpnSize parameter.

On input, specifies the size of the buffer, in TCHARs. On output, the number of TCHARs copied to the destination buffer, not including the terminating null character. If the buffer is too small, the function fails and GetLastError returns ERROR_BUFFER_OVERFLOW. The lpnSize parameter specifies the size of the buffer required, including the terminating null character.

A string that specifies a directory on a disk. If this parameter is NULL, the function uses the root of the current disk. If this parameter is a UNC name, it must include a trailing backslash, for example, \\MyServer\MyShare\. This parameter does not have to specify the root directory on a disk. The function accepts any directory on a disk.

A pointer to a variable that receives the total number of free bytes on a disk that are available to the user who is associated with the calling thread. This parameter can be NULL.

A pointer to a variable that receives the total number of bytes on a disk that are available to the user who is associated with the calling thread. This parameter can be NULL.

A pointer to a variable that receives the total number of free bytes on a disk. This parameter can be NULL.

A handle to the process.

A pointer to a variable to receive the process termination status.

The name of the file or directory. Prepend \\?\ to the path for names up to 32,767 wide characters

A handle to the file or directory for which dates and times are to be retrieved. The handle must have been created using the CreateFile function with the GENERIC_READ access right.

A pointer to a FILETIME structure to receive the date and time the file or directory was created. This parameter can be NULL if the application does not require this information.

A pointer to a FILETIME structure to receive the date and time the file or directory was last accessed. The last access time includes the last time the file or directory was written to, read from, or, in the case of executable files, run. This parameter can be NULL if the application does not require this information.

A pointer to a FILETIME structure to receive the date and time the file or directory was last written to, truncated, or overwritten (for example, with WriteFile or SetEndOfFile). This date and time is not updated when file attributes or security descriptors are changed. This parameter can be NULL if the application does not require this information.

Maximum size of the buffer pointed to by lpBuffer, in TCHARs. This size does not include the terminating null character. If this parameter is zero, lpBuffer is not used.

Pointer to a buffer that receives a series of null-terminated strings, one for each valid drive in the system, plus with an additional null character. Each string is a device name.

The type of relationship to retrieve. This parameter can be one of the following values: com.sun.jna.platform.win32.WinNT.LOGICAL_PROCESSOR_RELATIONSHIP#RelationCache, com.sun.jna.platform.win32.WinNT.LOGICAL_PROCESSOR_RELATIONSHIP#RelationGroup, com.sun.jna.platform.win32.WinNT.LOGICAL_PROCESSOR_RELATIONSHIP#RelationNumaNode, com.sun.jna.platform.win32.WinNT.LOGICAL_PROCESSOR_RELATIONSHIP#RelationProcessorCore, com.sun.jna.platform.win32.WinNT.LOGICAL_PROCESSOR_RELATIONSHIP#RelationProcessorPackage, or com.sun.jna.platform.win32.WinNT.LOGICAL_PROCESSOR_RELATIONSHIP#RelationAll

A pointer to a buffer that receives an array of WinNT.SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX structures. If the function fails, the contents of this buffer are undefined.

On input, specifies the length of the buffer pointed to by Buffer, in bytes. If the buffer is large enough to contain all of the data, this function succeeds and ReturnedLength is set to the number of bytes returned. If the buffer is not large enough to contain all of the data, the function fails, GetLastError returns WinError#ERROR_INSUFFICIENT_BUFFER, and ReturnedLength is set to the buffer length required to contain all of the data. If the function fails with an error other than WinError#ERROR_INSUFFICIENT_BUFFER, the value of ReturnedLength is undefined.

A handle to an instance of a named pipe.

The buffer to receive the computer name

The size of the ClientComputerName buffer, in bytes.

A handle to an instance of a named pipe.

Recipient of the session identifier

A handle to the named pipe instance.

A pointer to a variable that receives the type of the named pipe. This parameter can be null if this information is not needed.

A pointer to a variable that receives the size of the buffer for outgoing data, in bytes. This parameter can be null if this information is not needed.

A pointer to a variable that receives the size of the buffer for incoming data, in bytes. This parameter can be null if this information is not needed.

A pointer to a variable that receives the maximum number of pipe instances that can be created. This parameter can be null if this information is not needed.

A handle to an instance of a named pipe.

session identifier.

A handle to the process.

The name of the section in the initialization file.

A buffer that receives the key name and value pairs associated with the named section. The buffer is filled with one or more null -terminated strings; the last string is followed by a second null character.

The size of the buffer pointed to by the lpReturnedString parameter, in characters. The maximum profile section size is 32,767 characters.

The name of the initialization file. If this parameter does not contain a full path to the file, the system searches for the file in the Windows directory.

The name of the section containing the key name. If this parameter is null, the GetPrivateProfileString function copies all section names in the file to the supplied buffer.

The name of the key whose associated string is to be retrieved. If this parameter is null, all key names in the section specified by the lpAppName parameter are copied to the buffer specified by the lpReturnedString parameter.

A default string. If the lpKeyName key cannot be found in the initialization file, GetPrivateProfileString copies the default string to the lpReturnedString buffer. If this parameter is null, the default is an empty string, "".

Avoid specifying a default string with trailing blank characters. The function inserts a null character in the lpReturnedString buffer to strip any trailing blanks.

A pointer to the buffer that receives the retrieved string.

The size of the buffer pointed to by the lpReturnedString parameter, in characters.

The name of the initialization file. If this parameter does not contain a full path to the file, the system searches for the file in the Windows directory.

A handle to the process whose affinity mask is desired.

This handle must have the WinNT#PROCESS_QUERY_INFORMATION or WinNT#PROCESS_QUERY_LIMITED_INFORMATION access right.

A pointer to a variable that receives the affinity mask for the specified process.

A pointer to a variable that receives the affinity mask for the system.

A handle to the process. The handle must have the PROCESS_QUERY_INFORMATION or PROCESS_QUERY_LIMITED_INFORMATION access right.

A pointer to an IO_COUNTERS structure that receives the I/O accounting information for the process.

Process identifier of the process of interest. A value of zero specifies the calling process.

The path string.

A pointer to a buffer to receive the null-terminated short form of the path that lpszLongPath specifies.

The size of the buffer that lpszShortPath points to, in TCHARs.

Pointer to a SYSTEM_INFO structure that receives the information.

A pointer to a WinBase.FILETIME structure that receives the amount of time that the system has been idle.

A pointer to a WinBase.FILETIME structure that receives the amount of time that the system has spent executing in Kernel mode (including all threads in all processes, on all processors). This time value also includes the amount of time the system has been idle.

A pointer to a WinBase.FILETIME structure that receives the amount of time that the system has spent executing in User mode (including all threads in all processes, on all processors).

A handle to the process.

Pointer to an OSVERSIONINFOEX data structure that the function fills with operating system version information.

A string that contains the path of a mounted folder (e.g., "Y:\MountX\") or a drive letter (for example, "X:\"). The string must end with a trailing backslash.

A buffer that receives the volume GUID path - if there is more than one volume GUID path for the volume, only the first one in the mount manager's cache is returned.

The length of the output buffer - a reasonable size for the buffer to accommodate the largest possible volume GUID path is at 50 characters

A volume GUID path for the volume

A buffer that receives the list of drive letters and mounted folder paths. The list is an array of null-terminated strings terminated by an additional NULL character. If the buffer is not large enough to hold the complete list, the buffer holds as much of the list as possible.

The available length of the buffer - including all NULL characters.

If the call is successful, this parameter is the number of character copied to the buffer. Otherwise, this parameter is the size of the buffer required to hold the complete list

A pointer to a MEMORYSTATUSEX structure that receives information about current memory availability.

A string that specifies the file name of the module to load. This name is not related to the name stored in a library module itself, as specified by the LIBRARY keyword in the module-definition (.def) file.
The module can be a library module (a .dll file) or an executable module (an .exe file). If the specified module is an executable module, static imports are not loaded; instead, the module is loaded as if DONT_RESOLVE_DLL_REFERENCES was specified. See the dwFlags parameter for more information.
If the string specifies a module name without a path and the file name extension is omitted, the function appends the default library extension .dll to the module name. To prevent the function from appending .dll to the module name, include a trailing point character (.) in the module name string.
If the string specifies a fully qualified path, the function searches only that path for the module. When specifying a path, be sure to use backslashes (\), not forward slashes (/). For more information about paths, see "Naming Files, Paths, and Namespaces" on MSDN.
If the string specifies a module name without a path and more than one loaded module has the same base name and extension, the function returns a handle to the module that was loaded first.
If the string specifies a module name without a path and a module of the same name is not already loaded, or if the string specifies a module name with a relative path, the function searches for the specified module. The function also searches for modules if loading the specified module causes the system to load other associated modules (that is, if the module has dependencies). The directories that are searched and the order in which they are searched depend on the specified path and the dwFlags parameter. For more information, see Remarks.
If the function cannot find the module or one of its dependencies, the function fails.

This parameter is reserved for future use. It must be NULL.

The action to be taken when loading the module.
If no flags are specified, the behavior of this function is identical to that of the LoadLibrary function.
This parameter can be one of the following values.

DONT_RESOLVE_DLL_REFERENCES: 0x00000001
If this value is used, and the executable module is a DLL, the system does not call DllMain for process and thread initialization and termination. Also, the system does not load additional executable modules that are referenced by the specified module.
Do not use this value; it is provided only for backward compatibility. If you are planning to access only data or resources in the DLL, use LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE or LOAD_LIBRARY_AS_IMAGE_RESOURCE or both. Otherwise, load the library as a DLL or executable module using the LoadLibrary function.

LOAD_IGNORE_CODE_AUTHZ_LEVEL: 0x00000010
If this value is used, the system does not check AppLocker rules or apply Software Restriction Policies for the DLL. AppLocker was introduced in Windows 7 and Windows Server 2008 R2. This action applies only to the DLL being loaded and not to its dependencies. This value is recommended for use in setup programs that must run extracted DLLs during installation.
Windows Server 2008 R2 and Windows 7: On systems with KB2532445 installed, the caller must be running as "LocalSystem" or "TrustedInstaller"; otherwise the system ignores this flag.

LOAD_LIBRARY_AS_DATAFILE: 0x00000002
If this value is used, the system maps the file into the calling process's virtual address space as if it were a data file. Nothing is done to execute or prepare to execute the mapped file. Therefore, you cannot call functions like GetModuleFileName, GetModuleHandle or GetProcAddress with this DLL. Using this value causes writes to read-only memory to raise an access violation. Use this flag when you want to load a DLL only to extract messages or resources from it.
This value can be used with LOAD_LIBRARY_AS_IMAGE_RESOURCE. For more information, see Remarks

LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE: 0x00000040
Similar to LOAD_LIBRARY_AS_DATAFILE, except that the DLL file is opened with exclusive write access for the calling process. Other processes cannot open the DLL file for write access while it is in use. However, the DLL can still be opened by other processes.
This value can be used with LOAD_LIBRARY_AS_IMAGE_RESOURCE. This value is not supported until Windows Vista.

LOAD_LIBRARY_AS_IMAGE_RESOURCE: 0x00000020
If this value is used, the system maps the file into the process's virtual address space as an image file. However, the loader does not load the static imports or perform the other usual initialization steps. Use this flag when you want to load a DLL only to extract messages or resources from it.
Unless the application depends on the file having the in-memory layout of an image, this value should be used with either LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE or LOAD_LIBRARY_AS_DATAFILE. This value is not supported until Windows Vista.

LOAD_LIBRARY_SEARCH_APPLICATION_DIR: 0x00000200
If this value is used, the application's installation directory is searched for the DLL and its dependencies. Directories in the standard search path are not searched. This value cannot be combined with LOAD_WITH_ALTERED_SEARCH_PATH.
Windows 7, Windows Server 2008 R2, Windows Vista, and Windows Server 2008: This value requires KB2533623 to be installed.

LOAD_LIBRARY_SEARCH_DEFAULT_DIRS: 0x00001000
This value is a combination of LOAD_LIBRARY_SEARCH_APPLICATION_DIR, LOAD_LIBRARY_SEARCH_SYSTEM32, and LOAD_LIBRARY_SEARCH_USER_DIRS. Directories in the standard search path are not searched. This value cannot be combined with LOAD_WITH_ALTERED_SEARCH_PATH.
This value represents the recommended maximum number of directories an application should include in its DLL search path.
Windows 7, Windows Server 2008 R2, Windows Vista, and Windows Server 2008: This value requires KB2533623 to be installed.

LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR: 0x00000100
If this value is used, the directory that contains the DLL is temporarily added to the beginning of the list of directories that are searched for the DLL's dependencies. Directories in the standard search path are not searched.
The lpFileName parameter must specify a fully qualified path. This value cannot be combined with LOAD_WITH_ALTERED_SEARCH_PATH.
For example, if Lib2.dll is a dependency of C:\Dir1\Lib1.dll, loading Lib1.dll with this value causes the system to search for Lib2.dll only in C:\Dir1. To search for Lib2.dll in C:\Dir1 and all of the directories in the DLL search path, combine this value with LOAD_LIBRARY_DEFAULT_DIRS.
Windows 7, Windows Server 2008 R2, Windows Vista, and Windows Server 2008: This value requires KB2533623 to be installed.

LOAD_LIBRARY_SEARCH_SYSTEM32: 0x00000800
If this value is used, %windows%\system32 is searched for the DLL and its dependencies. Directories in the standard search path are not searched. This value cannot be combined with LOAD_WITH_ALTERED_SEARCH_PATH.
Windows 7, Windows Server 2008 R2, Windows Vista, and Windows Server 2008: This value requires KB2533623 to be installed.

LOAD_LIBRARY_SEARCH_USER_DIRS: 0x00000400
If this value is used, directories added using the AddDllDirectory or the SetDllDirectory function are searched for the DLL and its dependencies. If more than one directory has been added, the order in which the directories are searched is unspecified. Directories in the standard search path are not searched. This value cannot be combined with LOAD_WITH_ALTERED_SEARCH_PATH.
Windows 7, Windows Server 2008 R2, Windows Vista, and Windows Server 2008: This value requires KB2533623 to be installed.

LOAD_WITH_ALTERED_SEARCH_PATH: 0x00000008
If this value is used and lpFileName specifies an absolute path, the system uses the alternate file search strategy discussed in the Remarks section to find associated executable modules that the specified module causes to be loaded. If this value is used and lpFileName specifies a relative path, the behavior is undefined.
If this value is not used, or if lpFileName does not specify a path, the system uses the standard search strategy discussed in the Remarks section to find associated executable modules that the specified module causes to be loaded.
This value cannot be combined with any LOAD_LIBRARY_SEARCH flag.

Memory allocation attributes. The default is the LMEM_FIXED value.

Number of bytes to allocate. If this parameter is zero and the uFlags parameter specifies LMEM_MOVEABLE, the function returns a handle to a memory object that is marked as discarded.

A handle to the resource to be accessed.
The LoadResource function returns this handle.
Note that this parameter is listed as an HGLOBAL variable only for backward compatibility.
Do not pass any value as a parameter other than a successful return value from the LoadResource function.

A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.

A pointer to a MODULEENTRY32 structure.

The current name of the file or directory on the local computer. The name is limited to MAX_PATH characters. To extend this limit to 32,767 wide characters, prepend "\\?\" to the path. For more information, see Naming a File.

The new name for the file or directory. The new name must not already exist. A new file may be on a different file system or drive. A new directory must be on the same drive. The name is limited to MAX_PATH characters. To extend this limit to 32,767 wide characters, prepend "\\?\" to the path. For more information, see Naming a File.

The access to the event object. The function fails if the security descriptor of the specified object does not permit the requested access for the calling process. For a list of access rights, see Synchronization Object Security and Access Rights.

If this value is TRUE, processes created by this process will inherit the handle. Otherwise, the processes do not inherit this handle.

The name of the event to be opened. Name comparisons are case sensitive.

This function can open objects in a private namespace. For more information, see Object Namespaces.

Terminal Services: The name can have a "Global" or "Local" prefix to explicitly open an object in the global or session namespace. The remainder of the name can contain any character except the backslash character (). For more information, see Kernel Object Namespaces.

The access to the mutex object. Only the WinNT#SYNCHRONIZE access right is required to use a mutex; to change the mutex's security, specify WinBase#MUTEX_ALL_ACCESS.

If this value is TRUE, processes created by this process will inherit the handle. Otherwise, the processes do not inherit this handle.

The name of the mutex to be opened. Name comparisons are case sensitive.

This function can open objects in a private namespace.

Terminal Services: The name can have a "Global\" or "Local\" prefix to explicitly open an object in the global or session namespace. The remainder of the name can contain any character except the backslash character (\).

Access to the thread object. This access right is checked against any security descriptor for the thread.

If this parameter is TRUE, the new process inherits the handle. If the parameter is FALSE, the handle is not inherited.

Identifier of the thread to be opened.

A handle to an I/O completion port to which the I/O completion packet is to be posted.

The value to be returned through the lpNumberOfBytesTransferred parameter of the GetQueuedCompletionStatus function.

The value to be returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function.

The value to be returned through the lpOverlapped parameter of the GetQueuedCompletionStatus function.

A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.

A pointer to a PROCESSENTRY32 structure.

A handle to the event object. The CreateEvent or OpenEvent function returns this handle.

Handle for the running process

0 - The name should use the Win32 path format. 1(WinNT.PROCESS_NAME_NATIVE) - The name should use the native system path format.

pre-allocated character buffer for the returned path

input: the size of the allocated buffer output: the length of the returned path in characters

A handle to the device (for example, a file, file stream, physical disk, volume, console buffer, tape drive, socket, communications resource, mailslot, or pipe).

A pointer to the buffer that receives the data read from a file or device.

The maximum number of bytes to be read.

A pointer to the variable that receives the number of bytes read when using a synchronous hFile parameter

A pointer to an OVERLAPPED structure is required if the hFile parameter was opened with FILE_FLAG_OVERLAPPED, otherwise it can be NULL.

A pointer to a Unicode string that specifies the command-line arguments for the application when it is restarted. The maximum size of the command line that you can specify is RESTART_MAX_CMD_LINE characters. Do not include the name of the executable in the command line; this function adds it for you.

If this parameter is NULL or an empty string, the previously registered command line is removed. If the argument contains spaces, use quotes around the argument.

This parameter can be 0 or one or more of the following values.

Value	Meaning
RESTART_NO_CRASH (1)	Do not restart the process if it terminates due to an unhandled exception.
RESTART_NO_HANG (2)	Do not restart the process if it terminates due to the application not responding.
RESTART_NO_PATCH (4)	Do not restart the process if it terminates due to the installation of an update.
RESTART_NO_REBOOT (8)	Do not restart the process if the computer is restarted as the result of an update.

A handle to the event object

[in] A handle to the communications device. The com.sun.jna.platform.win32.Kernel32#CreateFile(String, int, int, com.sun.jna.platform.win32.WinBase.SECURITY_ATTRIBUTES, int, int, com.sun.jna.platform.win32.WinNT.HANDLE) function returns this handle.

[in] A pointer to a WinBase.COMMTIMEOUTS structure that contains the new time-out values.

The process error mode.

The name of the file whose attributes are to be set. The name is limited to MAX_PATH characters. To extend this limit to 32,767 wide characters, prepend "\\?\" to the path.

The file attributes to set for the file. This parameter can be one or more values, combined using the bitwise-OR operator. However, all other values override FILE_ATTRIBUTE_NORMAL.

A handle to the file or directory. The handle must have been created using the CreateFile function with the FILE_WRITE_ATTRIBUTES access right. For more information, see File Security and Access Rights.

A pointer to a FILETIME structure that contains the new creation date and time for the file or directory. This parameter can be NULL if the application does not need to change this information.

A pointer to a FILETIME structure that contains the new last access date and time for the file or directory. The last access time includes the last time the file or directory was written to, read from, or (in the case of executable files) run. This parameter can be NULL if the application does not need to change this information. To preserve the existing last access time for a file even after accessing a file, call SetFileTime immediately after opening the file handle with this parameter's FILETIME structure members initialized to 0xFFFFFFFF.

A pointer to a FILETIME structure that contains the new last modified date and time for the file or directory. This parameter can be NULL if the application does not need to change this information.

Last-error code for the thread.

A handle to the named pipe instance.

The new pipe mode. The mode is a combination of a read-mode flag and a wait-mode flag. This parameter can be null if the mode is not being set.

The maximum number of bytes collected on the client computer before transmission to the server. This parameter can be null if the count is not being set.

The maximum time, in milliseconds, that can pass before a remote named pipe transfers information over the network. This parameter can be null if the timeout is not being set.

A handle to the process whose affinity mask is to be set. This handle must have the WinNT#PROCESS_SET_INFORMATION access right.

The affinity mask for the threads of the process.

On a system with more than 64 processors, the affinity mask must specify processors in a single processor group.

The thread's execution requirements. This parameter can be one or more of the following values (ORed together)

• com.sun.jna.platform.win32.WinBase#ES_AWAYMODE_REQUIRED
• com.sun.jna.platform.win32.WinBase#ES_CONTINUOUS
• com.sun.jna.platform.win32.WinBase#ES_DISPLAY_REQUIRED
• com.sun.jna.platform.win32.WinBase#ES_SYSTEM_REQUIRED
• com.sun.jna.platform.win32.WinBase#ES_USER_PRESENT

The volume's drive letter (for example, X:\) or the path of a mounted folder that is associated with the volume (for example, Y:\MountX\). The string must end with a trailing backslash. If this parameter is NULL, the root of the current directory is used.

The new label for the volume. If this parameter is NULL, the function deletes any existing label from the specified volume and does not assign a new label.

A handle to the module whose executable file contains the resource.

A handle to the resource. This handle must be created by using the FindResource or FindResourceEx function.

[in, optional] A pointer to a TIME_ZONE_INFORMATION structure that specifies the time zone of interest. If lpTimeZone is NULL, the function uses the currently active time zone.

[in] A pointer to a SYSTEMTIME structure that specifies the UTC time to be converted. The function converts this universal time to the specified time zone's corresponding local time.

[out] A pointer to a SYSTEMTIME structure that receives the local time.

A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.

A pointer to a THREADENTRY32 structure.

A handle to the named pipe

The buffer containing the data to be written to the pipe.

The size of the input buffer, in bytes.

The buffer that receives the data read from the pipe.

The size of the output buffer, in bytes.

Variable that receives the number of bytes read from the pipe.

A pointer to an WinBase.OVERLAPPED structure. Can be null if pipe not opened with FILE_FLAG_OVERLAPPED.

A value to be passed as the dwlConditionMask parameter of the VerifyVersionInfoW function. The function stores the comparison information in the bits of this variable.

Before the first call to VerSetConditionMask, initialize this variable to zero. For subsequent calls, pass in the variable used in the previous call.

A mask that indicates the member of the com.sun.jna.platform.win32.WinNT.OSVERSIONINFOEX structure whose comparison operator is being set. This value corresponds to one of the bits specified in the dwTypeMask parameter for the VerifyVersionInfoW function.

The operator to be used for the comparison. The VerifyVersionInfoW function uses this operator to compare a specified attribute value to the corresponding value for the currently running system.

A handle to a process. The function frees memory within the virtual address space of the process.

The handle must have the PROCESS_VM_OPERATION access right.

A pointer to the starting address of the region of memory to be freed.

If the dwFreeType parameter is MEM_RELEASE, lpAddress must be the base address returned by the VirtualAllocEx function when the region is reserved.

The size of the region of memory to free, in bytes.

If the dwFreeType parameter is MEM_RELEASE, dwSize must be 0 (zero). The function frees the entire region that is reserved in the initial allocation call to VirtualAllocEx.

If dwFreeType is MEM_DECOMMIT, the function decommits all memory pages that contain one or more bytes in the range from the lpAddress parameter to (lpAddress+dwSize). This means, for example, that a 2-byte region of memory that straddles a page boundary causes both pages to be decommitted. If lpAddress is the base address returned by VirtualAllocEx and dwSize is 0 (zero), the function decommits the entire region that is allocated by VirtualAllocEx. After that, the entire region is in the reserved state.

One of the following values:

• WinNT#MEM_COALESCE_PLACEHOLDERS
• WinNT#MEM_PRESERVE_PLACEHOLDER
• WinNT#MEM_DECOMMIT
• WinNT#MEM_RELEASE

A handle to the process whose memory information is queried.

The base address of the region of pages to be queried.

A WinNT.MEMORY_BASIC_INFORMATION structure in which information about the specified page range is returned.

The size of the buffer pointed to by the lpBuffer parameter, in bytes.

The number of object handles in the array pointed to by lpHandles. The maximum number of object handles is MAXIMUM_WAIT_OBJECTS.

An array of object handles. For a list of the object types whose handles can be specified, see the following Remarks section. The array can contain handles to objects of different types. It may not contain multiple copies of the same handle. If one of these handles is closed while the wait is still pending, the function's behavior is undefined. The handles must have the SYNCHRONIZE access right. For more information, see Standard Access Rights.

If this parameter is TRUE, the function returns when the state of all objects in the lpHandles array is signaled. If FALSE, the function returns when the state of any one of the objects is set to signaled. In the latter case, the return value indicates the object whose state caused the function to return.

The time-out interval, in milliseconds. If a nonzero value is specified, the function waits until the specified objects are signaled or the interval elapses. If dwMilliseconds is zero, the function does not enter a wait state if the specified objects are not signaled; it always returns immediately. If dwMilliseconds is INFINITE, the function will return only when the specified objects are signaled.

The name of the named pipe. The string must include the name of the computer on which the server process is executing. The following pipe name format is used:

\\servername\pipe\pipename

A period may be used for the servername if the pipe is local.

The number of milliseconds that the function will wait for an instance of the named pipe to be available.

The name of the section in which data is written. This section name is typically the name of the calling application.

The new key names and associated values that are to be written to the named section. This string is limited to 65,535 bytes. Must be filled with zero or many null-terminated strings of the form key=value, appended by an additional null byte to terminate the list.

The name of the initialization file. If this parameter does not contain a full path for the file, the function searches the Windows directory for the file. If the file does not exist and lpFileName does not contain a full path, the function creates the file in the Windows directory.

A handle to the process memory to be modified.

The base address in the specified process to which data is written.

The buffer that contains data to be written in the address space of the specified process.

The number of bytes to be written to the specified process.

A variable that receives the number of bytes transferred into the specified process. If null the parameter is ignored.