mirror of https://github.com/dahall/Vanara.git
1683 lines
86 KiB
C#
1683 lines
86 KiB
C#
using System;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using Vanara.Extensions;
|
|
using Vanara.InteropServices;
|
|
|
|
namespace Vanara.PInvoke
|
|
{
|
|
public static partial class Kernel32
|
|
{
|
|
/// <summary>
|
|
/// Application-defined callback function used to save data and application state information in the event the application encounters
|
|
/// an unhandled exception or becomes unresponsive.
|
|
/// </summary>
|
|
/// <param name="pvParameter">
|
|
/// Context information specified when you called the RegisterApplicationRecoveryCallback function to register for recovery.
|
|
/// </param>
|
|
/// <returns>The return value is not used and should be 0.</returns>
|
|
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa373202")]
|
|
public delegate uint ApplicationRecoveryCallback(IntPtr pvParameter);
|
|
|
|
/// <summary>
|
|
/// The <c>ACTCTX_COMPATIBILITY_ELEMENT_TYPE</c> enumeration describes the compatibility element in the application manifest.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-actctx_compatibility_element_type typedef enum {
|
|
// ACTCTX_COMPATIBILITY_ELEMENT_TYPE_UNKNOWN, ACTCTX_COMPATIBILITY_ELEMENT_TYPE_OS, ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MITIGATION,
|
|
// ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MAXVERSIONTESTED } ;
|
|
[PInvokeData("winnt.h", MSDNShortId = "3a3c99e5-9a73-4688-8192-baee0078c17c")]
|
|
public enum ACTCTX_COMPATIBILITY_ELEMENT_TYPE
|
|
{
|
|
/// <summary/>
|
|
ACTCTX_COMPATIBILITY_ELEMENT_TYPE_UNKNOWN,
|
|
|
|
/// <summary/>
|
|
ACTCTX_COMPATIBILITY_ELEMENT_TYPE_OS,
|
|
|
|
/// <summary/>
|
|
ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MITIGATION,
|
|
|
|
/// <summary/>
|
|
ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MAXVERSIONTESTED,
|
|
}
|
|
|
|
/// <summary>The <c>ACTCTX_REQUESTED_RUN_LEVEL</c> enumeration describes the requested run level of the activation context.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-actctx_requested_run_level typedef enum {
|
|
// ACTCTX_RUN_LEVEL_UNSPECIFIED, ACTCTX_RUN_LEVEL_AS_INVOKER, ACTCTX_RUN_LEVEL_HIGHEST_AVAILABLE, ACTCTX_RUN_LEVEL_REQUIRE_ADMIN,
|
|
// ACTCTX_RUN_LEVEL_NUMBERS } ;
|
|
[PInvokeData("winnt.h", MSDNShortId = "3bf75a4d-a209-43e4-9fe2-f7da1602fc6c")]
|
|
public enum ACTCTX_REQUESTED_RUN_LEVEL
|
|
{
|
|
/// <summary>The application manifest does not specify a requested run level for the application.</summary>
|
|
ACTCTX_RUN_LEVEL_UNSPECIFIED,
|
|
|
|
/// <summary>The application manifest requests the least privilege level to run the application.</summary>
|
|
ACTCTX_RUN_LEVEL_AS_INVOKER,
|
|
|
|
/// <summary>The application manifest requests the highest privilege level to run the application.</summary>
|
|
ACTCTX_RUN_LEVEL_HIGHEST_AVAILABLE,
|
|
|
|
/// <summary>The application manifest requests the administrator privilege level to run the application.</summary>
|
|
ACTCTX_RUN_LEVEL_REQUIRE_ADMIN,
|
|
|
|
/// <summary>Total number of possible run levels.</summary>
|
|
ACTCTX_RUN_LEVEL_NUMBERS,
|
|
}
|
|
|
|
/// <summary>Flags that determine in which section FindActCtxSectionString searches.</summary>
|
|
public enum ACTCTX_SECTION
|
|
{
|
|
/// <summary/>
|
|
ACTIVATION_CONTEXT_SECTION_ASSEMBLY_INFORMATION = 1,
|
|
/// <summary/>
|
|
ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION = 2,
|
|
/// <summary/>
|
|
ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION = 3,
|
|
/// <summary/>
|
|
ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION = 4,
|
|
/// <summary/>
|
|
ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION = 5,
|
|
/// <summary/>
|
|
ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION = 6,
|
|
/// <summary/>
|
|
ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION = 7,
|
|
/// <summary/>
|
|
ACTIVATION_CONTEXT_SECTION_GLOBAL_OBJECT_RENAME_TABLE = 8,
|
|
/// <summary/>
|
|
ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES = 9,
|
|
/// <summary/>
|
|
ACTIVATION_CONTEXT_SECTION_APPLICATION_SETTINGS = 10,
|
|
/// <summary/>
|
|
ACTIVATION_CONTEXT_SECTION_COMPATIBILITY_INFO = 11,
|
|
/// <summary/>
|
|
ACTIVATION_CONTEXT_SECTION_WINRT_ACTIVATABLE_CLASSES = 12
|
|
}
|
|
|
|
/// <summary>Flags that indicate how the values included in <see cref="ACTCTX"/> are to be used.</summary>
|
|
[Flags]
|
|
[PInvokeData("Winbase.h")]
|
|
public enum ActCtxFlags
|
|
{
|
|
/// <summary>No values are set.</summary>
|
|
ACTCTX_FLAG_NONE = 0x00000000,
|
|
|
|
/// <summary>The <see cref="ACTCTX.wProcessorArchitecture"/> value is set.</summary>
|
|
ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID = 0x00000001,
|
|
|
|
/// <summary>The <see cref="ACTCTX.wLangId"/> value is set.</summary>
|
|
ACTCTX_FLAG_LANGID_VALID = 0x00000002,
|
|
|
|
/// <summary>The <see cref="ACTCTX.lpAssemblyDirectory"/> value is set.</summary>
|
|
ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID = 0x00000004,
|
|
|
|
/// <summary>The <see cref="ACTCTX.lpResourceName"/> value is set.</summary>
|
|
ACTCTX_FLAG_RESOURCE_NAME_VALID = 0x00000008,
|
|
|
|
/// <summary>Set the activation context to be the process default when calling <see cref="CreateActCtx"/>.</summary>
|
|
ACTCTX_FLAG_SET_PROCESS_DEFAULT = 0x00000010,
|
|
|
|
/// <summary>The <see cref="ACTCTX.lpApplicationName"/> value is set.</summary>
|
|
ACTCTX_FLAG_APPLICATION_NAME_VALID = 0x00000020,
|
|
|
|
/// <summary>
|
|
/// Use when calling <see cref="CreateActCtx"/> to identify that <see cref="ACTCTX.lpSource"/> contains an assembly identifier.
|
|
/// </summary>
|
|
ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF = 0x00000040,
|
|
|
|
/// <summary>The <see cref="ACTCTX.hModule"/> value is set.</summary>
|
|
ACTCTX_FLAG_HMODULE_VALID = 0x00000080
|
|
}
|
|
|
|
/// <summary></summary>
|
|
public enum ACTIVATION_CONTEXT_INFO_CLASS
|
|
{
|
|
/// <summary>Not available.</summary>
|
|
[CorrespondingType(typeof(ACTIVATION_CONTEXT_BASIC_INFORMATION))]
|
|
ActivationContextBasicInformation = 1,
|
|
|
|
/// <summary>
|
|
/// If QueryActCtxW is called with this option and the function succeeds, the returned buffer contains detailed information about
|
|
/// the activation context. This information is in the form of the ACTIVATION_CONTEXT_DETAILED_INFORMATION structure.
|
|
/// </summary>
|
|
[CorrespondingType(typeof(ACTIVATION_CONTEXT_DETAILED_INFORMATION))]
|
|
ActivationContextDetailedInformation = 2,
|
|
|
|
/// <summary>
|
|
/// If QueryActCtxW is called with this option and the function succeeds, the buffer contains information about the assembly that
|
|
/// has the index specified in pvSubInstance. This information is in the form of the
|
|
/// ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION structure.
|
|
/// </summary>
|
|
[CorrespondingType(typeof(ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION))]
|
|
AssemblyDetailedInformationInActivationContext = 3,
|
|
|
|
/// <summary>
|
|
/// Information about a file in one of the assemblies in Activation Context. The pvSubInstance parameter must point to an
|
|
/// <see cref="ACTIVATION_CONTEXT_QUERY_INDEX"/> structure. If QueryActCtxW is called with this option and the function succeeds,
|
|
/// the returned buffer contains information for a file in the assembly. This information is in the form of the
|
|
/// ASSEMBLY_FILE_DETAILED_INFORMATION structure.
|
|
/// </summary>
|
|
[CorrespondingType(typeof(ASSEMBLY_FILE_DETAILED_INFORMATION))]
|
|
FileInformationInAssemblyOfAssemblyInActivationContext = 4,
|
|
|
|
/// <summary>
|
|
/// If QueryActCtxW is called with this option and the function succeeds, the buffer contains information about requested run
|
|
/// level of the activation context. This information is in the form of the ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION structure.
|
|
/// Windows Server 2003 and Windows XP: This value is not available.
|
|
/// </summary>
|
|
[CorrespondingType(typeof(ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION))]
|
|
RunlevelInformationInActivationContext = 5,
|
|
|
|
/// <summary>
|
|
/// If QueryActCtxW is called with this option and the function succeeds, the buffer contains information about requested
|
|
/// compatibility context. This information is in the form of the ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION structure.Windows
|
|
/// Server 2008 and earlier, and Windows Vista and
|
|
/// earlier: This value is not available. This option is available beginning with Windows Server 2008 R2 and Windows 7.
|
|
/// </summary>
|
|
[CorrespondingType(typeof(ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION))]
|
|
[CorrespondingType(typeof(ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION_UNMGD))]
|
|
CompatibilityInformationInActivationContext = 6,
|
|
|
|
/// <summary>The activation context manifest resource name</summary>
|
|
ActivationContextManifestResourceName = 7,
|
|
}
|
|
|
|
/// <summary></summary>
|
|
[Flags]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa373344")]
|
|
public enum ApplicationRestartFlags
|
|
{
|
|
/// <summary>Do not restart the process if it terminates due to an unhandled exception.</summary>
|
|
RESTART_NO_CRASH = 1,
|
|
|
|
/// <summary>Do not restart the process if it terminates due to the application not responding.</summary>
|
|
RESTART_NO_HANG = 2,
|
|
|
|
/// <summary>Do not restart the process if it terminates due to the installation of an update.</summary>
|
|
RESTART_NO_PATCH = 4,
|
|
|
|
/// <summary>Do not restart the process if the computer is restarted as the result of an update.</summary>
|
|
RESTART_NO_REBOOT = 8,
|
|
}
|
|
|
|
/// <summary></summary>
|
|
[PInvokeData("Winbase.h")]
|
|
public enum DeactivateActCtxFlag
|
|
{
|
|
/// <summary>
|
|
/// If this value is set and the cookie specified in the ulCookie parameter is in the top frame of the activation stack, the
|
|
/// activation context is popped from the stack and thereby deactivated.
|
|
/// <para>
|
|
/// If this value is set and the cookie specified in the ulCookie parameter is not in the top frame of the activation stack, this
|
|
/// function searches down the stack for the cookie.
|
|
/// </para>
|
|
/// <para>If the cookie is found, a STATUS_SXS_EARLY_DEACTIVATION exception is thrown.</para>
|
|
/// <para>If the cookie is not found, a STATUS_SXS_INVALID_DEACTIVATION exception is thrown.</para>
|
|
/// <para>This value should be specified in most cases.</para>
|
|
/// </summary>
|
|
None = 0,
|
|
|
|
/// <summary>
|
|
/// If this value is set and the cookie specified in the ulCookie parameter is in the top frame of the activation stack, the
|
|
/// function returns an ERROR_INVALID_PARAMETER error code. Call GetLastError to obtain this code.
|
|
/// <para>
|
|
/// If this value is set and the cookie is not on the activation stack, a STATUS_SXS_INVALID_DEACTIVATION exception will be thrown.
|
|
/// </para>
|
|
/// <para>
|
|
/// If this value is set and the cookie is in a lower frame of the activation stack, all of the frames down to and including the
|
|
/// frame the cookie is in is popped from the stack.
|
|
/// </para>
|
|
/// </summary>
|
|
DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION = 1
|
|
}
|
|
|
|
/// <summary>Flags that determine how FindActCtxSectionString operates.</summary>
|
|
public enum FIND_ACTCTX_SECTION
|
|
{
|
|
/// <summary>
|
|
/// This function returns the activation context handle where the redirection data was found in the hActCtx member of the
|
|
/// ACTCTX_SECTION_KEYED_DATA structure. The caller must use ReleaseActCtx to release this activation context.
|
|
/// </summary>
|
|
FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX = 0x00000001,
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
FIND_ACTCTX_SECTION_KEY_RETURN_FLAGS = 0x00000002,
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
FIND_ACTCTX_SECTION_KEY_RETURN_ASSEMBLY_METADATA = 0x00000004
|
|
}
|
|
|
|
/// <summary></summary>
|
|
[PInvokeData("Winbase.h")]
|
|
public enum QueryActCtxFlag : uint
|
|
{
|
|
/// <summary>
|
|
/// QueryActCtxW queries the activation context active on the thread instead of the context specified by hActCtx. This is usually
|
|
/// the last activation context passed to ActivateActCtx. If ActivateActCtx has not been called, the active activation context
|
|
/// can be the activation context used by the executable of the current process. In other cases, the operating system determines
|
|
/// the active activation context. For example, when the callback function to a new thread is called, the active activation
|
|
/// context may be the context that was active when you created the thread by calling CreateThread.
|
|
/// </summary>
|
|
QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX = 0x00000004,
|
|
|
|
/// <summary>
|
|
/// QueryActCtxW interprets hActCtx as an HMODULE data type and queries an activation context that is associated with a DLL or
|
|
/// EXE. When a DLL or EXE is loaded, the loader checks for a manifest stored in a resource. If the loader finds an RT_MANIFEST
|
|
/// resource with a resource identifier set to ISOLATIONAWARE_MANIFEST_ RESOURCE_ID, the loader associates the resulting
|
|
/// activation context with the DLL or EXE. This is the activation context that QueryActCtxW queries when the
|
|
/// QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE flag has been set.
|
|
/// </summary>
|
|
QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE = 0x00000008,
|
|
|
|
/// <summary>
|
|
/// QueryActCtxW interprets hActCtx as an address within a DLL or EXE and queries an activation context that has been associated
|
|
/// with the DLL or EXE. This can be any address within the DLL or EXE. For example, the address of any function within a DLL or
|
|
/// EXE or the address of any static data, such as a constant string. When a DLL or EXE is loaded, the loader checks for a
|
|
/// manifest stored in a resource in the same way as QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE.
|
|
/// </summary>
|
|
QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS = 0x00000010,
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
QUERY_ACTCTX_FLAG_NO_ADDREF = 0x80000000,
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>ActivateActCtx</c> 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.
|
|
/// </summary>
|
|
/// <param name="hActCtx">
|
|
/// Handle to an <c>ACTCTX</c> structure that contains information on the activation context that is to be made active.
|
|
/// </param>
|
|
/// <param name="lpCookie">
|
|
/// Pointer to a <c>ULONG_PTR</c> that functions as a cookie, uniquely identifying a specific, activated activation context.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, it returns <c>TRUE</c>. Otherwise, it returns <c>FALSE</c>.</para>
|
|
/// <para>
|
|
/// This function sets errors that can be retrieved by calling <c>GetLastError</c>. For an example, see Retrieving the Last-Error
|
|
/// Code. For a complete list of error codes, see System Error Codes.
|
|
/// </para>
|
|
/// </returns>
|
|
// BOOL ActivateActCtx( _In_ HANDLE hActCtx, _Out_ ULONG_PTR *lpCookie); https://msdn.microsoft.com/en-us/library/windows/desktop/aa374151(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa374151")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool ActivateActCtx(HACTCTX hActCtx, out IntPtr lpCookie);
|
|
|
|
/// <summary>The <c>AddRefActCtx</c> function increments the reference count of the specified activation context.</summary>
|
|
/// <param name="hActCtx">
|
|
/// Handle to an <c>ACTCTX</c> structure that contains information on the activation context for which the reference count is to be incremented.
|
|
/// </param>
|
|
/// <returns>This function does not return a value.</returns>
|
|
// void AddRefActCtx( _In_ HANDLE hActCtx); https://msdn.microsoft.com/en-us/library/windows/desktop/aa374171(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa374171")]
|
|
public static extern void AddRefActCtx(HACTCTX hActCtx);
|
|
|
|
/// <summary>Indicates that the calling application has completed its data recovery.</summary>
|
|
/// <param name="bSuccess">Specify <c>TRUE</c> to indicate that the data was successfully recovered; otherwise, <c>FALSE</c>.</param>
|
|
/// <returns>This function does not return a value.</returns>
|
|
// VOID WINAPI ApplicationRecoveryFinished( _In_ BOOL bSuccess); https://msdn.microsoft.com/en-us/library/windows/desktop/aa373328(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa373328")]
|
|
public static extern void ApplicationRecoveryFinished([MarshalAs(UnmanagedType.Bool)] bool bSuccess);
|
|
|
|
/// <summary>Indicates that the calling application is continuing to recover data.</summary>
|
|
/// <param name="pbCanceled">
|
|
/// Indicates whether the user has canceled the recovery process. Set by WER if the user clicks the Cancel button.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This function returns <c>S_OK</c> on success or one of the following error codes.</para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>E_FAIL</term>
|
|
/// <term>You can call this function only after Windows Error Reporting has called your recovery callback function.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>The pbCancelled cannot be NULL.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// </returns>
|
|
// HRESULT WINAPI ApplicationRecoveryInProgress( _Out_ PBOOL pbCanceled); https://msdn.microsoft.com/en-us/library/windows/desktop/aa373329(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa373329")]
|
|
public static extern HRESULT ApplicationRecoveryInProgress([Out, MarshalAs(UnmanagedType.Bool)] out bool pbCanceled);
|
|
|
|
/// <summary>The <c>CreateActCtx</c> function creates an activation context.</summary>
|
|
/// <param name="pActCtx">Pointer to an <c>ACTCTX</c> structure that contains information about the activation context to be created.</param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, it returns a handle to the returned activation context. Otherwise, it returns INVALID_HANDLE_VALUE.</para>
|
|
/// <para>
|
|
/// This function sets errors that can be retrieved by calling <c>GetLastError</c>. For an example, see Retrieving the Last-Error
|
|
/// Code. For a complete list of error codes, see System Error Codes.
|
|
/// </para>
|
|
/// </returns>
|
|
// HANDLE CreateActCtx( _Inout_ PACTCTX pActCtx); https://msdn.microsoft.com/en-us/library/windows/desktop/aa375125(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = true, CharSet = CharSet.Auto)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa375125")]
|
|
public static extern SafeHACTCTX CreateActCtx(in ACTCTX pActCtx);
|
|
|
|
/// <summary>The <c>DeactivateActCtx</c> function deactivates the activation context corresponding to the specified cookie.</summary>
|
|
/// <param name="dwFlags">
|
|
/// <para>Flags that indicate how the deactivation is to occur.</para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>0</term>
|
|
/// <term>
|
|
/// If this value is set and the cookie specified in the ulCookie parameter is in the top frame of the activation stack, the
|
|
/// activation context is popped from the stack and thereby deactivated. If this value is set and the cookie specified in the
|
|
/// ulCookie parameter is not in the top frame of the activation stack, this function searches down the stack for the cookie.If the
|
|
/// cookie is found, a STATUS_SXS_EARLY_DEACTIVATION exception is thrown.If the cookie is not found, a
|
|
/// STATUS_SXS_INVALID_DEACTIVATION exception is thrown.This value should be specified in most cases.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION</term>
|
|
/// <term>
|
|
/// If this value is set and the cookie specified in the ulCookie parameter is in the top frame of the activation stack, the function
|
|
/// returns an ERROR_INVALID_PARAMETER error code. Call GetLastError to obtain this code. If this value is set and the cookie is not
|
|
/// on the activation stack, a STATUS_SXS_INVALID_DEACTIVATION exception will be thrown.If this value is set and the cookie is in a
|
|
/// lower frame of the activation stack, all of the frames down to and including the frame the cookie is in is popped from the stack.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// </param>
|
|
/// <param name="ulCookie">
|
|
/// The ULONG_PTR that was passed into the call to <c>ActivateActCtx</c>. This value is used as a cookie to identify a specific
|
|
/// activated activation context.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, it returns <c>TRUE</c>. Otherwise, it returns <c>FALSE</c>.</para>
|
|
/// <para>
|
|
/// This function sets errors that can be retrieved by calling <c>GetLastError</c>. For an example, see Retrieving the Last-Error
|
|
/// Code. For a complete list of error codes, see System Error Codes.
|
|
/// </para>
|
|
/// </returns>
|
|
// BOOL DeactivateActCtx( _In_ DWORD dwFlags, _In_ ULONG_PTR ulCookie); https://msdn.microsoft.com/en-us/library/windows/desktop/aa375140(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa375140")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool DeactivateActCtx(DeactivateActCtxFlag dwFlags, IntPtr ulCookie);
|
|
|
|
/// <summary>
|
|
/// The <c>FindActCtxSectionGuid</c> function retrieves information on a specific GUID in the current activation context and returns
|
|
/// a <c>ACTCTX_SECTION_KEYED_DATA</c> structure.
|
|
/// </summary>
|
|
/// <param name="dwFlags">
|
|
/// <para>Flags that determine how this function is to operate. Only the following flag is currently defined.</para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX</term>
|
|
/// <term>
|
|
/// This function returns the activation context handle where the redirection data was found in the hActCtx member of the
|
|
/// ACTCTX_SECTION_KEYED_DATA structure. The caller must use ReleaseActCtx to release this activation context.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// </param>
|
|
/// <param name="lpExtensionGuid">Reserved; must be null.</param>
|
|
/// <param name="ulSectionId">
|
|
/// <para>Identifier of the section of the activation context in which to search for the specified GUID.</para>
|
|
/// <para>The following are valid GUID section identifiers:</para>
|
|
/// <para>The following is a valid GUID section identifier beginning with Windows Server 2003 and Windows XP with SP1:</para>
|
|
/// </param>
|
|
/// <param name="lpGuidToFind">Pointer to a GUID to be used as the search criteria.</param>
|
|
/// <param name="ReturnedData">
|
|
/// Pointer to an <c>ACTCTX_SECTION_KEYED_DATA</c> structure to be filled out with the requested GUID information.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, it returns <c>TRUE</c>. Otherwise, it returns <c>FALSE</c>.</para>
|
|
/// <para>
|
|
/// This function sets errors that can be retrieved by calling <c>GetLastError</c>. For an example, see Retrieving the Last-Error
|
|
/// Code. For a complete list of error codes, see System Error Codes.
|
|
/// </para>
|
|
/// </returns>
|
|
// BOOL FindActCtxSectionGuid( _In_ DWORD dwFlags, _In_ const GUID *lpExtensionGuid, _In_ ULONG ulSectionId, _In_ const GUID
|
|
// *lpGuidToFind, _Out_ PACTCTX_SECTION_KEYED_DATA ReturnedData); https://msdn.microsoft.com/en-us/library/windows/desktop/aa375148(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa375148")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool FindActCtxSectionGuid(FIND_ACTCTX_SECTION dwFlags, [Optional] IntPtr lpExtensionGuid, ACTCTX_SECTION ulSectionId, in Guid lpGuidToFind, out ACTCTX_SECTION_KEYED_DATA ReturnedData);
|
|
|
|
/// <summary>
|
|
/// The <c>FindActCtxSectionString</c> function retrieves information on a specific string in the current activation context and
|
|
/// returns a <c>ACTCTX_SECTION_KEYED_DATA</c> structure.
|
|
/// </summary>
|
|
/// <param name="dwFlags">
|
|
/// <para>Flags that determine how this function is to operate. Only the following flag is currently defined.</para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX</term>
|
|
/// <term>
|
|
/// This function returns the activation context handle where the redirection data was found in the hActCtx member of the
|
|
/// ACTCTX_SECTION_KEYED_DATA structure. The caller must use ReleaseActCtx to release this activation context.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// </param>
|
|
/// <param name="lpExtensionGuid">Reserved; must be null.</param>
|
|
/// <param name="ulSectionId">
|
|
/// <para>Identifier of the string section of the activation context in which to search for the specific string.</para>
|
|
/// <para>The following are valid string section identifiers:</para>
|
|
/// </param>
|
|
/// <param name="lpStringToFind">Pointer to a null-terminated string to be used as the search criteria.</param>
|
|
/// <param name="ReturnedData">
|
|
/// Pointer to an <c>ACTCTX_SECTION_KEYED_DATA</c> structure to be filled out with the requested string information.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, it returns <c>TRUE</c>. Otherwise, it returns <c>FALSE</c>.</para>
|
|
/// <para>
|
|
/// This function sets errors that can be retrieved by calling <c>GetLastError</c>. For an example, see Retrieving the Last-Error
|
|
/// Code. For a complete list of error codes, see System Error Codes.
|
|
/// </para>
|
|
/// </returns>
|
|
// BOOL FindActCtxSectionString( _In_ DWORD dwFlags, _In_ const GUID *lpExtensionGuid, _In_ ULONG ulSectionId, _In_ LPCTSTR
|
|
// lpStringToFind, _Out_ PACTCTX_SECTION_KEYED_DATA ReturnedData); https://msdn.microsoft.com/en-us/library/windows/desktop/aa375149(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = true, CharSet = CharSet.Auto)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa375149")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool FindActCtxSectionString(FIND_ACTCTX_SECTION dwFlags, [Optional] IntPtr lpExtensionGuid, ACTCTX_SECTION ulSectionId, string lpStringToFind, out ACTCTX_SECTION_KEYED_DATA ReturnedData);
|
|
|
|
/// <summary>
|
|
/// Retrieves a pointer to the callback routine registered for the specified process. The address returned is in the virtual address
|
|
/// space of the process.
|
|
/// </summary>
|
|
/// <param name="hProcess">A handle to the process. This handle must have the PROCESS_VM_READ access right.</param>
|
|
/// <param name="pRecoveryCallback">A pointer to the recovery callback function. For more information, see <c>ApplicationRecoveryCallback</c>.</param>
|
|
/// <param name="ppvParameter">A pointer to the callback parameter.</param>
|
|
/// <param name="pdwPingInterval">The recovery ping interval, in 100-nanosecond intervals.</param>
|
|
/// <param name="pdwFlags">Reserved for future use.</param>
|
|
/// <returns>
|
|
/// <para>This function returns <c>S_OK</c> on success or one of the following error codes.</para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>S_FALSE</term>
|
|
/// <term>The application did not register for recovery.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>One or more parameters are not valid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// </returns>
|
|
// HRESULT WINAPI GetApplicationRecoveryCallback( _In_ HANDLE hProcess, _Out_ APPLICATION_RECOVERY_CALLBACK *pRecoveryCallback, _Out_ PVOID
|
|
// *ppvParameter, _Out_ PDWORD pdwPingInterval, _Out_ PDWORD pdwFlags); https://msdn.microsoft.com/en-us/library/windows/desktop/aa373343(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa373343")]
|
|
public static extern HRESULT GetApplicationRecoveryCallback(HPROCESS hProcess, out ApplicationRecoveryCallback pRecoveryCallback, out IntPtr ppvParameter, out uint pdwPingInterval, out int pdwFlags);
|
|
|
|
/// <summary>Retrieves the restart information registered for the specified process.</summary>
|
|
/// <param name="hProcess">A handle to the process. This handle must have the PROCESS_VM_READ access right.</param>
|
|
/// <param name="pwzCommandline">
|
|
/// A pointer to a buffer that receives the restart command line specified by the application when it called the
|
|
/// <c>RegisterApplicationRestart</c> function. The maximum size of the command line, in characters, is RESTART_MAX_CMD_LINE. Can be
|
|
/// <c>NULL</c> if pcchSize is zero.
|
|
/// </param>
|
|
/// <param name="pcchSize">
|
|
/// <para>On input, specifies the size of the pwzCommandLine buffer, in characters.</para>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <para>On output, specifies the size of the buffer that was used.</para>
|
|
/// <para>
|
|
/// To determine the required buffer size, set pwzCommandLine to <c>NULL</c> and this parameter to zero. The size includes one for
|
|
/// the <c>null</c>-terminator character. Note that the function returns S_OK, not HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) in
|
|
/// this case.
|
|
/// </para>
|
|
/// </param>
|
|
/// <param name="pdwFlags">
|
|
/// A pointer to a variable that receives the flags specified by the application when it called the <c>RegisterApplicationRestart</c> function.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This function returns <c>S_OK</c> on success or one of the following error codes.</para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>One or more parameters are not valid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>HRESULT_FROM_WIN32(ERROR_NOT_FOUND)</term>
|
|
/// <term>The application did not register for restart.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)</term>
|
|
/// <term>
|
|
/// The pwzCommandLine buffer is too small. The function returns the required buffer size in pcchSize. Use the required size to
|
|
/// reallocate the buffer.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// </returns>
|
|
// HRESULT WINAPI GetApplicationRestartSettings( _In_ HANDLE hProcess, _Out_opt_ PWSTR pwzCommandline, _Inout_ PDWORD pcchSize,
|
|
// _Out_opt_ PDWORD pdwFlags); https://msdn.microsoft.com/en-us/library/windows/desktop/aa373344(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true, CharSet = CharSet.Unicode)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa373344")]
|
|
public static extern HRESULT GetApplicationRestartSettings(HPROCESS hProcess, StringBuilder pwzCommandline, ref uint pcchSize, out ApplicationRestartFlags pdwFlags);
|
|
|
|
/// <summary>The <c>GetCurrentActCtx</c> function returns the handle to the active activation context of the calling thread.</summary>
|
|
/// <param name="lphActCtx">
|
|
/// Pointer to the returned <c>ACTCTX</c> structure that contains information on the active activation context.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, it returns <c>TRUE</c>. Otherwise, it returns <c>FALSE</c>.</para>
|
|
/// <para>
|
|
/// This function sets errors that can be retrieved by calling <c>GetLastError</c>. For an example, see Retrieving the Last-Error
|
|
/// Code. For a complete list of error codes, see System Error Codes.
|
|
/// </para>
|
|
/// </returns>
|
|
// BOOL GetCurrentActCtx( _Out_ HANDLE *lphActCtx); https://msdn.microsoft.com/en-us/library/windows/desktop/aa375152(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa375152")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool GetCurrentActCtx(out HACTCTX lphActCtx);
|
|
|
|
/// <summary>
|
|
/// The <c>QueryActCtxSettingsW</c> function specifies the activation context, and the namespace and name of the attribute that is to
|
|
/// be queried.
|
|
/// </summary>
|
|
/// <param name="dwFlags">This value must be 0.</param>
|
|
/// <param name="hActCtx">A handle to the activation context that is being queried.</param>
|
|
/// <param name="settingsNameSpace">
|
|
/// <para>
|
|
/// A pointer to a string that contains the value <c>"http://schemas.microsoft.com/SMI/2005/WindowsSettings"</c> or <c>NULL</c>.
|
|
/// These values are equivalent.
|
|
/// </para>
|
|
/// <para>
|
|
/// <c>Windows 8 and Windows Server 2012:</c> A pointer to a string that contains the value
|
|
/// <c>"http://schemas.microsoft.com/SMI/2011/WindowsSettings"</c> is also a valid parameter. A <c>NULL</c> is still equivalent to
|
|
/// the previous value.
|
|
/// </para>
|
|
/// </param>
|
|
/// <param name="settingName">The name of the attribute to be queried.</param>
|
|
/// <param name="pvBuffer">A pointer to the buffer that receives the query result.</param>
|
|
/// <param name="dwBuffer">The size of the buffer in characters that receives the query result.</param>
|
|
/// <param name="pdwWrittenOrRequired">
|
|
/// A pointer to a value which is the number of characters written to the buffer specified by pvBuffer or that is required to hold
|
|
/// the query result.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, it returns <c>TRUE</c>. Otherwise, it returns <c>FALSE</c>.</para>
|
|
/// <para>
|
|
/// This function sets errors that can be retrieved by calling <c>GetLastError</c>. For an example, see Retrieving the Last-Error
|
|
/// Code. For a complete list of error codes, see System Error Codes.
|
|
/// </para>
|
|
/// </returns>
|
|
// BOOL QueryActCtxSettingsW( _In_opt_ DWORD dwFlags, _In_opt_ HANDLE hActCtx, _In_opt_ PCWSTR settingsNameSpace, _In_ PCWSTR
|
|
// settingName, _Out_ PWSTR pvBuffer, _In_ SIZE_T dwBuffer, _Out_opt_ SIZE_T *pdwWrittenOrRequired); https://msdn.microsoft.com/en-us/library/windows/desktop/aa375700(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa375700")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool QueryActCtxSettingsW([Optional] uint dwFlags, [In] HACTCTX hActCtx, [Optional] string settingsNameSpace, string settingName, StringBuilder pvBuffer, SizeT dwBuffer, out SizeT pdwWrittenOrRequired);
|
|
|
|
/// <summary>The <c>QueryActCtxW</c> function queries the activation context.</summary>
|
|
/// <param name="dwFlags">
|
|
/// <para>This parameter should be set to one of the following flag bits.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Flag</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX</term>
|
|
/// <term>
|
|
/// QueryActCtxW queries the activation context active on the thread instead of the context specified by hActCtx. This is usually the
|
|
/// last activation context passed to ActivateActCtx. If ActivateActCtx has not been called, the active activation context can be the
|
|
/// activation context used by the executable of the current process. In other cases, the operating system determines the active
|
|
/// activation context. For example, when the callback function to a new thread is called, the active activation context may be the
|
|
/// context that was active when you created the thread by calling CreateThread.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE</term>
|
|
/// <term>
|
|
/// QueryActCtxW interprets hActCtx as an HMODULE data type and queries an activation context that is associated with a DLL or EXE.
|
|
/// When a DLL or EXE is loaded, the loader checks for a manifest stored in a resource. If the loader finds an RT_MANIFEST resource
|
|
/// with a resource identifier set to ISOLATIONAWARE_MANIFEST_ RESOURCE_ID, the loader associates the resulting activation context
|
|
/// with the DLL or EXE. This is the activation context that QueryActCtxW queries when the QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE flag
|
|
/// has been set.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS</term>
|
|
/// <term>
|
|
/// QueryActCtxW interprets hActCtx as an address within a DLL or EXE and queries an activation context that has been associated with
|
|
/// the DLL or EXE. This can be any address within the DLL or EXE. For example, the address of any function within a DLL or EXE or
|
|
/// the address of any static data, such as a constant string. When a DLL or EXE is loaded, the loader checks for a manifest stored
|
|
/// in a resource in the same way as QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </param>
|
|
/// <param name="hActCtx">Handle to the activation context that is being queried.</param>
|
|
/// <param name="pvSubInstance">
|
|
/// <para>
|
|
/// Index of the assembly, or assembly and file combination, in the activation context. The meaning of the pvSubInstance depends on
|
|
/// the option specified by the value of the ulInfoClass parameter.
|
|
/// </para>
|
|
/// <para>This parameter may be null.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>ulInfoClass Option</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>AssemblyDetailedInformationInActivationContext</term>
|
|
/// <term>
|
|
/// Pointer to a DWORD that specifies the index of the assembly within the activation context. This is the activation context that
|
|
/// QueryActCtxW queries.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>FileInformationInAssemblyOfAssemblyInActivationContext</term>
|
|
/// <term>
|
|
/// Pointer to an ACTIVATION_CONTEXT_QUERY_INDEX structure. If QueryActCtxW is called with this option and the function succeeds, the
|
|
/// returned buffer contains information for a file in the assembly. This information is in the form of the
|
|
/// ASSEMBLY_FILE_DETAILED_INFORMATION structure.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </param>
|
|
/// <param name="ulInfoClass">
|
|
/// <para>This parameter can have only the values shown in the following table.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Option</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ActivationContextBasicInformation 1</term>
|
|
/// <term>Not available.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ActivationContextDetailedInformation 2</term>
|
|
/// <term>
|
|
/// If QueryActCtxW is called with this option and the function succeeds, the returned buffer contains detailed information about the
|
|
/// activation context. This information is in the form of the ACTIVATION_CONTEXT_DETAILED_INFORMATION structure.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>AssemblyDetailedInformationInActivationContext 3</term>
|
|
/// <term>
|
|
/// If QueryActCtxW is called with this option and the function succeeds, the buffer contains information about the assembly that has
|
|
/// the index specified in pvSubInstance. This information is in the form of the ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION structure.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>FileInformationInAssemblyOfAssemblyInActivationContext 4</term>
|
|
/// <term>
|
|
/// Information about a file in one of the assemblies in Activation Context. The pvSubInstance parameter must point to an
|
|
/// ACTIVATION_CONTEXT_QUERY_INDEX structure. If QueryActCtxW is called with this option and the function succeeds, the returned
|
|
/// buffer contains information for a file in the assembly. This information is in the form of the ASSEMBLY_FILE_DETAILED_INFORMATION structure.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>RunlevelInformationInActivationContext 5</term>
|
|
/// <term>
|
|
/// If QueryActCtxW is called with this option and the function succeeds, the buffer contains information about requested run level
|
|
/// of the activation context. This information is in the form of the ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION structure. Windows
|
|
/// Server 2003 and Windows XP: This value is not available.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>CompatibilityInformationInActivationContext 6</term>
|
|
/// <term>
|
|
/// If QueryActCtxW is called with this option and the function succeeds, the buffer contains information about requested
|
|
/// compatibility context. This information is in the form of the ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION structure. Windows
|
|
/// Server 2008 and earlier, and Windows Vista and earlier: This value is not available. This option is available beginning with
|
|
/// Windows Server 2008 R2 and Windows 7.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </param>
|
|
/// <param name="pvBuffer">
|
|
/// Pointer to a buffer that holds the returned information. This parameter is optional. If pvBuffer is <c>null</c>, then cbBuffer
|
|
/// must be zero. If the size of the buffer pointed to by pvBuffer is too small, <c>QueryActCtxW</c> returns
|
|
/// ERROR_INSUFFICIENT_BUFFER and no data is written into the buffer. See the Remarks section for the method you can use to determine
|
|
/// the required size of the buffer.
|
|
/// </param>
|
|
/// <param name="cbBuffer">Size of the buffer in bytes pointed to by pvBuffer. This parameter is optional.</param>
|
|
/// <param name="pcbWrittenOrRequired">
|
|
/// Number of bytes written or required. The parameter pcbWrittenOrRequired can only be <c>NULL</c> when pvBuffer is <c>NULL</c>. If
|
|
/// pcbWrittenOrRequired is non- <c>NULL</c>, it is filled with the number of bytes required to store the returned buffer.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, it returns <c>TRUE</c>. Otherwise, it returns <c>FALSE</c>.</para>
|
|
/// <para>
|
|
/// This function sets errors that can be retrieved by calling GetLastError. For an example, see Retrieving the Last-Error Code. For
|
|
/// a complete list of error codes, see System Error Codes.
|
|
/// </para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The parameter cbBuffer specifies the size in bytes of the buffer pointed to by pvBuffer. If pvBuffer is <c>NULL</c>, then
|
|
/// cbBuffer must be 0. The parameter pcbWrittenOrRequired can only be <c>NULL</c> if pvBuffer is <c>NULL</c>. If
|
|
/// pcbWrittenOrRequired is non- <c>NULL</c> on return, it is filled with the number of bytes required to store the returned
|
|
/// information. When the information data returned is larger than the provided buffer, <c>QueryActCtxW</c> returns
|
|
/// ERROR_INSUFFICIENT_BUFFER and no data is written to the buffer pointed to by pvBuffer.
|
|
/// </para>
|
|
/// <para>The following example shows the method of calling first with a small buffer and then recalling if the buffer is too small.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-queryactctxw
|
|
// BOOL QueryActCtxW( DWORD dwFlags, HANDLE hActCtx, PVOID pvSubInstance, ULONG ulInfoClass, PVOID pvBuffer, SIZE_T cbBuffer, SIZE_T *pcbWrittenOrRequired );
|
|
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
|
|
[PInvokeData("winbase.h", MSDNShortId = "7d45f63f-0baf-4236-b245-d36f9eb32e8c")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool QueryActCtxW(QueryActCtxFlag dwFlags, [In] HACTCTX hActCtx, [In, Optional] IntPtr pvSubInstance, ACTIVATION_CONTEXT_INFO_CLASS ulInfoClass, IntPtr pvBuffer, SizeT cbBuffer, out SizeT pcbWrittenOrRequired);
|
|
|
|
/// <summary>The <c>QueryActCtxW</c> function queries the activation context.</summary>
|
|
/// <typeparam name="T">The type of the requested return value.</typeparam>
|
|
/// <param name="dwFlags">
|
|
/// <para>This parameter should be set to one of the following flag bits.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Flag</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX</term>
|
|
/// <term>
|
|
/// QueryActCtxW queries the activation context active on the thread instead of the context specified by hActCtx. This is usually the
|
|
/// last activation context passed to ActivateActCtx. If ActivateActCtx has not been called, the active activation context can be the
|
|
/// activation context used by the executable of the current process. In other cases, the operating system determines the active
|
|
/// activation context. For example, when the callback function to a new thread is called, the active activation context may be the
|
|
/// context that was active when you created the thread by calling CreateThread.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE</term>
|
|
/// <term>
|
|
/// QueryActCtxW interprets hActCtx as an HMODULE data type and queries an activation context that is associated with a DLL or EXE.
|
|
/// When a DLL or EXE is loaded, the loader checks for a manifest stored in a resource. If the loader finds an RT_MANIFEST resource
|
|
/// with a resource identifier set to ISOLATIONAWARE_MANIFEST_ RESOURCE_ID, the loader associates the resulting activation context
|
|
/// with the DLL or EXE. This is the activation context that QueryActCtxW queries when the QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE flag
|
|
/// has been set.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS</term>
|
|
/// <term>
|
|
/// QueryActCtxW interprets hActCtx as an address within a DLL or EXE and queries an activation context that has been associated with
|
|
/// the DLL or EXE. This can be any address within the DLL or EXE. For example, the address of any function within a DLL or EXE or
|
|
/// the address of any static data, such as a constant string. When a DLL or EXE is loaded, the loader checks for a manifest stored
|
|
/// in a resource in the same way as QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </param>
|
|
/// <param name="hActCtx">Handle to the activation context that is being queried.</param>
|
|
/// <param name="ulInfoClass">
|
|
/// <para>This parameter can have only the values shown in the following table.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Option</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ActivationContextBasicInformation 1</term>
|
|
/// <term>Not available.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ActivationContextDetailedInformation 2</term>
|
|
/// <term>
|
|
/// If QueryActCtxW is called with this option and the function succeeds, the returned buffer contains detailed information about the
|
|
/// activation context. This information is in the form of the ACTIVATION_CONTEXT_DETAILED_INFORMATION structure.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>AssemblyDetailedInformationInActivationContext 3</term>
|
|
/// <term>
|
|
/// If QueryActCtxW is called with this option and the function succeeds, the buffer contains information about the assembly that has
|
|
/// the index specified in pvSubInstance. This information is in the form of the ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION structure.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>FileInformationInAssemblyOfAssemblyInActivationContext 4</term>
|
|
/// <term>
|
|
/// Information about a file in one of the assemblies in Activation Context. The pvSubInstance parameter must point to an
|
|
/// ACTIVATION_CONTEXT_QUERY_INDEX structure. If QueryActCtxW is called with this option and the function succeeds, the returned
|
|
/// buffer contains information for a file in the assembly. This information is in the form of the ASSEMBLY_FILE_DETAILED_INFORMATION structure.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>RunlevelInformationInActivationContext 5</term>
|
|
/// <term>
|
|
/// If QueryActCtxW is called with this option and the function succeeds, the buffer contains information about requested run level
|
|
/// of the activation context. This information is in the form of the ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION structure. Windows
|
|
/// Server 2003 and Windows XP: This value is not available.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>CompatibilityInformationInActivationContext 6</term>
|
|
/// <term>
|
|
/// If QueryActCtxW is called with this option and the function succeeds, the buffer contains information about requested
|
|
/// compatibility context. This information is in the form of the ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION structure. Windows
|
|
/// Server 2008 and earlier, and Windows Vista and earlier: This value is not available. This option is available beginning with
|
|
/// Windows Server 2008 R2 and Windows 7.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </param>
|
|
/// <param name="pvSubInstance">
|
|
/// <para>
|
|
/// Index of the assembly, or assembly and file combination, in the activation context. The meaning of the pvSubInstance depends on
|
|
/// the option specified by the value of the ulInfoClass parameter.
|
|
/// </para>
|
|
/// <para>This parameter may be null.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>ulInfoClass Option</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>AssemblyDetailedInformationInActivationContext</term>
|
|
/// <term>
|
|
/// Pointer to a DWORD that specifies the index of the assembly within the activation context. This is the activation context that
|
|
/// QueryActCtxW queries.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>FileInformationInAssemblyOfAssemblyInActivationContext</term>
|
|
/// <term>
|
|
/// Pointer to an ACTIVATION_CONTEXT_QUERY_INDEX structure. If QueryActCtxW is called with this option and the function succeeds, the
|
|
/// returned buffer contains information for a file in the assembly. This information is in the form of the
|
|
/// ASSEMBLY_FILE_DETAILED_INFORMATION structure.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </param>
|
|
/// <returns>The returned information.</returns>
|
|
/// <exception cref="ArgumentException"></exception>
|
|
public static T QueryActCtxW<T>(QueryActCtxFlag dwFlags, [In] HACTCTX hActCtx, ACTIVATION_CONTEXT_INFO_CLASS ulInfoClass, [In] object pvSubInstance = null) where T : struct
|
|
{
|
|
if (!CorrespondingTypeAttribute.CanGet(ulInfoClass, typeof(T))) throw new ArgumentException();
|
|
if (!QueryActCtxW(dwFlags, hActCtx, pvSubInstance is null ? IntPtr.Zero : new PinnedObject(pvSubInstance), ulInfoClass, default, 0, out var req) && req == 0)
|
|
Win32Error.ThrowLastError();
|
|
using (var mem = new SafeCoTaskMemHandle(req))
|
|
{
|
|
if (!QueryActCtxW(dwFlags, hActCtx, pvSubInstance is null ? IntPtr.Zero : new PinnedObject(pvSubInstance), ulInfoClass, (IntPtr)mem, mem.Size, out req))
|
|
Win32Error.ThrowLastError();
|
|
if (typeof(T) == typeof(ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION))
|
|
return (T)(object)new ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION((IntPtr)mem);
|
|
return mem.ToStructure<T>();
|
|
}
|
|
}
|
|
|
|
/// <summary>Registers the active instance of an application for recovery.</summary>
|
|
/// <param name="pRecoveryCallback">A pointer to the recovery callback function. For more information, see <c>ApplicationRecoveryCallback</c>.</param>
|
|
/// <param name="pvParameter">A pointer to a variable to be passed to the callback function. Can be <c>NULL</c>.</param>
|
|
/// <param name="dwPingInterval">
|
|
/// <para>
|
|
/// The recovery ping interval, in milliseconds. By default, the interval is 5 seconds (RECOVERY_DEFAULT_PING_INTERVAL). The maximum
|
|
/// interval is 5 minutes. If you specify zero, the default interval is used.
|
|
/// </para>
|
|
/// <para>
|
|
/// You must call the <c>ApplicationRecoveryInProgress</c> function within the specified interval to indicate to ARR that you are
|
|
/// still actively recovering; otherwise, WER terminates recovery. Typically, you perform recovery in a loop with each iteration
|
|
/// lasting no longer than the ping interval. Each iteration performs a block of recovery work followed by a call to
|
|
/// <c>ApplicationRecoveryInProgress</c>. Since you also use <c>ApplicationRecoveryInProgress</c> to determine if the user wants to
|
|
/// cancel recovery, you should consider a smaller interval, so you do not perform a lot of work unnecessarily.
|
|
/// </para>
|
|
/// </param>
|
|
/// <param name="dwFlags">Reserved for future use. Set to zero.</param>
|
|
/// <returns>
|
|
/// <para>This function returns <c>S_OK</c> on success or one of the following error codes.</para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>E_FAIL</term>
|
|
/// <term>Internal error; the registration failed.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>The ping interval cannot be more than five minutes.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// </returns>
|
|
// HRESULT WINAPI RegisterApplicationRecoveryCallback( _In_ APPLICATION_RECOVERY_CALLBACK pRecoveryCallback, _In_opt_ PVOID
|
|
// pvParameter, _In_ DWORD dwPingInterval, _In_ DWORD dwFlags); https://msdn.microsoft.com/en-us/library/windows/desktop/aa373345(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa373345")]
|
|
public static extern HRESULT RegisterApplicationRecoveryCallback(ApplicationRecoveryCallback pRecoveryCallback, [Optional] IntPtr pvParameter, [Optional] uint dwPingInterval, [Optional] uint dwFlags);
|
|
|
|
/// <summary>Registers the active instance of an application for restart.</summary>
|
|
/// <param name="pwzCommandline">
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <para>
|
|
/// If this parameter is <c>NULL</c> or an empty string, the previously registered command line is removed. If the argument contains
|
|
/// spaces, use quotes around the argument.
|
|
/// </para>
|
|
/// </param>
|
|
/// <param name="dwFlags">
|
|
/// <para>This parameter can be 0 or one or more of the following values.</para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>RESTART_NO_CRASH1</term>
|
|
/// <term>Do not restart the process if it terminates due to an unhandled exception.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>RESTART_NO_HANG2</term>
|
|
/// <term>Do not restart the process if it terminates due to the application not responding.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>RESTART_NO_PATCH4</term>
|
|
/// <term>Do not restart the process if it terminates due to the installation of an update.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>RESTART_NO_REBOOT8</term>
|
|
/// <term>Do not restart the process if the computer is restarted as the result of an update.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>This function returns <c>S_OK</c> on success or one of the following error codes.</para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>E_FAIL</term>
|
|
/// <term>Internal error.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>E_INVALIDARG</term>
|
|
/// <term>The specified command line is too long.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// </returns>
|
|
// HRESULT WINAPI RegisterApplicationRestart( _In_opt_ PCWSTR pwzCommandline, _In_ DWORD dwFlags); https://msdn.microsoft.com/en-us/library/windows/desktop/aa373347(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true, CharSet = CharSet.Unicode)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa373347")]
|
|
public static extern HRESULT RegisterApplicationRestart(string pwzCommandline, ApplicationRestartFlags dwFlags);
|
|
|
|
/// <summary>The <c>ReleaseActCtx</c> function decrements the reference count of the specified activation context.</summary>
|
|
/// <param name="hActCtx">
|
|
/// Handle to the <c>ACTCTX</c> structure that contains information on the activation context for which the reference count is to be decremented.
|
|
/// </param>
|
|
/// <returns>
|
|
/// This function does not return a value. On successful completion, the activation context reference count is decremented. The
|
|
/// recipient of the reference-counted object must decrement the reference count when the object is no longer required.
|
|
/// </returns>
|
|
// void ReleaseActCtx( _In_ HANDLE hActCtx); https://msdn.microsoft.com/en-us/library/windows/desktop/aa375713(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa375713")]
|
|
public static extern void ReleaseActCtx(HACTCTX hActCtx);
|
|
|
|
/// <summary>Removes the active instance of an application from the recovery list.</summary>
|
|
/// <returns>
|
|
/// <para>This function returns <c>S_OK</c> on success or one of the following error codes.</para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>E_FAIL</term>
|
|
/// <term>Internal error.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// </returns>
|
|
// HRESULT WINAPI UnregisterApplicationRecoveryCallback(void); https://msdn.microsoft.com/en-us/library/windows/desktop/aa373348(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa373348")]
|
|
public static extern HRESULT UnregisterApplicationRecoveryCallback();
|
|
|
|
/// <summary>Removes the active instance of an application from the restart list.</summary>
|
|
/// <remarks>
|
|
/// You do not need to call this function before exiting. You need to remove the registration only if you choose to not restart the
|
|
/// application. For example, you could remove the registration if your application entered a corrupted state where a future restart
|
|
/// would also fail. You must call this function before the application fails abnormally.
|
|
/// </remarks>
|
|
/// <returns>This function returns S_OK on success</returns>
|
|
[DllImport(Lib.Kernel32, ExactSpelling = true)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa373349")]
|
|
public static extern HRESULT UnregisterApplicationRestart();
|
|
|
|
/// <summary>The <c>ZombifyActCtx</c> function deactivates the specified activation context, but does not deallocate it.</summary>
|
|
/// <param name="hActCtx">Handle to the activation context that is to be deactivated.</param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, it returns <c>TRUE</c>. If a <c>null</c> handle is passed in the hActCtx parameter,
|
|
/// NULL_INVALID_PARAMETER will be returned. Otherwise, it returns <c>FALSE</c>.
|
|
/// </para>
|
|
/// <para>
|
|
/// This function sets errors that can be retrieved by calling <c>GetLastError</c>. For an example, see Retrieving the Last-Error
|
|
/// Code. For a complete list of error codes, see System Error Codes.
|
|
/// </para>
|
|
/// </returns>
|
|
// BOOL ZombifyActCtx( _In_ HANDLE hActCtx); https://msdn.microsoft.com/en-us/library/windows/desktop/aa376622(v=vs.85).aspx
|
|
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa376622")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool ZombifyActCtx(HACTCTX hActCtx);
|
|
|
|
/// <summary>The ACTCTX structure is used by the CreateActCtx function to create the activation context.</summary>
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa374149")]
|
|
public struct ACTCTX
|
|
{
|
|
/// <summary>The size, in bytes, of this structure. This is used to determine the version of this structure.</summary>
|
|
public int cbSize;
|
|
|
|
/// <summary>
|
|
/// Flags that indicate how the values included in this structure are to be used. Set any undefined bits in dwFlags to 0. If any
|
|
/// undefined bits are not set to 0, the call to CreateActCtx that creates the activation context fails and returns an invalid
|
|
/// parameter error code.
|
|
/// </summary>
|
|
public ActCtxFlags dwFlags;
|
|
|
|
/// <summary>
|
|
/// Null-terminated string specifying the path of the manifest file or PE image to be used to create the activation context. If
|
|
/// this path refers to an EXE or DLL file, the lpResourceName member is required.
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.LPTStr)] public string lpSource;
|
|
|
|
/// <summary>Identifies the type of processor used. Specifies the system's processor architecture.</summary>
|
|
public ProcessorArchitecture wProcessorArchitecture;
|
|
|
|
/// <summary>
|
|
/// Specifies the language manifest that should be used. The default is the current user's current UI language.
|
|
/// <para>If the requested language cannot be found, an approximation is searched for using the following order:</para>
|
|
/// <list type="bullet">
|
|
/// <item>
|
|
/// <description>The current user's specific language. For example, for US English (1033).</description>
|
|
/// </item>
|
|
/// <item>
|
|
/// <description>The current user's primary language. For example, for English (9).</description>
|
|
/// </item>
|
|
/// <item>
|
|
/// <description>The current system's specific language.</description>
|
|
/// </item>
|
|
/// <item>
|
|
/// <description>The current system's primary language.</description>
|
|
/// </item>
|
|
/// <item>
|
|
/// <description>A nonspecific worldwide language. Language neutral (0).</description>
|
|
/// </item>
|
|
/// </list>
|
|
/// </summary>
|
|
public ushort wLangId;
|
|
|
|
/// <summary>
|
|
/// The base directory in which to perform private assembly probing if assemblies in the activation context are not present in
|
|
/// the system-wide store.
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.LPTStr)] public string lpAssemblyDirectory;
|
|
|
|
/// <summary>
|
|
/// Pointer to a null-terminated string that contains the resource name to be loaded from the PE specified in hModule or
|
|
/// lpSource. If the resource name is an integer, set this member using MAKEINTRESOURCE. This member is required if lpSource
|
|
/// refers to an EXE or DLL.
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.LPTStr)] public string lpResourceName;
|
|
|
|
/// <summary>
|
|
/// The name of the current application. If the value of this member is set to null, the name of the executable that launched the
|
|
/// current process is used.
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.LPTStr)] public string lpApplicationName;
|
|
|
|
/// <summary>
|
|
/// Use this member rather than lpSource if you have already loaded a DLL and wish to use it to create activation contexts rather
|
|
/// than using a path in lpSource. See lpResourceName for the rules of looking up resources in this module.
|
|
/// </summary>
|
|
public HINSTANCE hModule;
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="ACTCTX"/> struct.</summary>
|
|
/// <param name="source">The source.</param>
|
|
public ACTCTX(string source) : this()
|
|
{
|
|
cbSize = Marshal.SizeOf(typeof(ACTCTX));
|
|
lpSource = source;
|
|
}
|
|
|
|
/// <summary>Gets an empty instance with only the cbSize parameter initialized.</summary>
|
|
public static ACTCTX Empty => new ACTCTX { cbSize = Marshal.SizeOf(typeof(ACTCTX)) };
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>ACTCTX_SECTION_KEYED_DATA</c> structure is used by the <c>FindActCtxSectionString</c> and <c>FindActCtxSectionGuid</c>
|
|
/// functions to return the activation context information along with either the GUID or 32-bit integer-tagged activation context section.
|
|
/// </summary>
|
|
// typedef struct tagACTCTX_SECTION_KEYED_DATA { ULONG cbSize; ULONG ulDataFormatVersion; PVOID lpData; ULONG ulLength; PVOID
|
|
// lpSectionGlobalData; ULONG ulSectionGlobalDataLength; PVOID lpSectionBase; ULONG ulSectionTotalLength; HANDLE hActCtx; HANDLE
|
|
// ulAssemblyRosterIndex;} ACTCTX_SECTION_KEYED_DATA, *PACTCTX_SECTION_KEYED_DATA;
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
[PInvokeData("Winbase.h", MSDNShortId = "aa374148")]
|
|
public struct ACTCTX_SECTION_KEYED_DATA
|
|
{
|
|
/// <summary>
|
|
/// <para>The size, in bytes, of the activation context keyed data structure.</para>
|
|
/// </summary>
|
|
public uint cbSize;
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// Number that indicates the format of the data in the section where the key was found. Clients should verify that the data
|
|
/// format version is as expected rather than trying to interpret the values of unfamiliar data formats. This number is only
|
|
/// changed when major non-backward-compatible changes to the section data formats need to be made. The current format version is 1.
|
|
/// </para>
|
|
/// </summary>
|
|
public uint ulDataFormatVersion;
|
|
|
|
/// <summary>
|
|
/// <para>Pointer to the redirection data found associated with the section identifier and key.</para>
|
|
/// </summary>
|
|
public IntPtr lpData;
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// Number of bytes in the structure referred to by <c>lpData</c>. Note that the data structures grow over time; do not access
|
|
/// members in the instance data that extend beyond <c>ulLength</c>.
|
|
/// </para>
|
|
/// </summary>
|
|
public uint ulLength;
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// Returned pointer to a section-specific data structure which is global to the activation context section where the key was
|
|
/// found. Its interpretation depends on the section identifier requested.
|
|
/// </para>
|
|
/// </summary>
|
|
public IntPtr lpSectionGlobalData;
|
|
|
|
/// <summary>
|
|
/// <para>Number of bytes in the section global data block referred to by <c>lpSectionGlobalData</c>.</para>
|
|
/// <para>
|
|
/// Note that the data structures grow over time and you may receive an old format activation context data block; do not access
|
|
/// members in the section global data that extend beyond <c>ulSectionGlobalDataLength</c>.
|
|
/// </para>
|
|
/// </summary>
|
|
public uint ulSectionGlobalDataLength;
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// Pointer to the base of the section where the key was found. Some instance data contains offsets relative to the section base
|
|
/// address, in which case this pointer value is used.
|
|
/// </para>
|
|
/// </summary>
|
|
public IntPtr lpSectionBase;
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// Number of bytes for the entire section starting at <c>lpSectionBase</c>. May be used to verify that offset/length pairs,
|
|
/// which are specified as relative to the section base are wholly contained in the section.
|
|
/// </para>
|
|
/// </summary>
|
|
public uint ulSectionTotalLength;
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// Handle to the activation context where the key was found. First, the active activation context for the thread is searched,
|
|
/// followed by the process-default activation context and then the system-compatible-default-activation context. This member
|
|
/// indicates which activation context contained the section and key requested. This is only returned if the
|
|
/// FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX flag is passed.
|
|
/// </para>
|
|
/// <para>
|
|
/// Note that when this is returned, the caller must call <c>ReleaseActCtx</c>() on the activation context handle returned to
|
|
/// release system resources when all other references to the activation context have been released.
|
|
/// </para>
|
|
/// </summary>
|
|
public HACTCTX hActCtx;
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// Cardinal number of the assembly in the activation context that provided the redirection information found. This value can be
|
|
/// presented to <c>QueryActCtxW</c> for more information about the contributing assembly.
|
|
/// </para>
|
|
/// </summary>
|
|
public uint ulAssemblyRosterIndex;
|
|
}
|
|
|
|
/// <summary>The <c>ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION</c> structure is used by the QueryActCtxW function.</summary>
|
|
/// <remarks>
|
|
/// If QueryActCtxW is called with the AssemblyDetailedInformationInActivationContext option, and the function succeeds, the
|
|
/// information in the returned buffer is in the form of the <c>ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION</c> structure.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-activation_context_assembly_detailed_information typedef struct
|
|
// _ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION { DWORD ulFlags; DWORD ulEncodedAssemblyIdentityLength; DWORD
|
|
// ulManifestPathType; DWORD ulManifestPathLength; LARGE_INTEGER liManifestLastWriteTime; DWORD ulPolicyPathType; DWORD
|
|
// ulPolicyPathLength; LARGE_INTEGER liPolicyLastWriteTime; DWORD ulMetadataSatelliteRosterIndex; DWORD ulManifestVersionMajor; DWORD
|
|
// ulManifestVersionMinor; DWORD ulPolicyVersionMajor; DWORD ulPolicyVersionMinor; DWORD ulAssemblyDirectoryNameLength; PCWSTR
|
|
// lpAssemblyEncodedAssemblyIdentity; PCWSTR lpAssemblyManifestPath; PCWSTR lpAssemblyPolicyPath; PCWSTR lpAssemblyDirectoryName;
|
|
// DWORD ulFileCount; } ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION, *PACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION;
|
|
[PInvokeData("winnt.h", MSDNShortId = "b093cc6a-55ea-49bf-904d-2b43517f9b02")]
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
|
|
public struct ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION
|
|
{
|
|
/// <summary>This value is always 0.</summary>
|
|
public uint ulFlags;
|
|
|
|
/// <summary>Length of the encoded assembly identity in bytes.</summary>
|
|
public uint ulEncodedAssemblyIdentityLength;
|
|
|
|
/// <summary>This value always a constant.</summary>
|
|
public uint ulManifestPathType;
|
|
|
|
/// <summary>Length of the assembly manifest path in bytes.</summary>
|
|
public uint ulManifestPathLength;
|
|
|
|
/// <summary>The last time the manifest was written. This is in the form of a <c>FILETIME</c> data structure.</summary>
|
|
public int liManifestLastWriteTime;
|
|
|
|
/// <summary>This value always a constant.</summary>
|
|
public uint ulPolicyPathType;
|
|
|
|
/// <summary>Length of the publisher policy path in bytes.</summary>
|
|
public uint ulPolicyPathLength;
|
|
|
|
/// <summary>The last time the policy was written. This is in the form of a <c>FILETIME</c> data structure.</summary>
|
|
public int liPolicyLastWriteTime;
|
|
|
|
/// <summary>Metadata satellite roster index.</summary>
|
|
public uint ulMetadataSatelliteRosterIndex;
|
|
|
|
/// <summary>Major version of the assembly queried by QueryActCtxW. For more information, see Assembly Versions.</summary>
|
|
public uint ulManifestVersionMajor;
|
|
|
|
/// <summary>Minor version of the assembly queried by QueryActCtxW. For more information, see Assembly Versions.</summary>
|
|
public uint ulManifestVersionMinor;
|
|
|
|
/// <summary>Major version of any policy, if one exists.</summary>
|
|
public uint ulPolicyVersionMajor;
|
|
|
|
/// <summary>Minor version of any policy, if one exists.</summary>
|
|
public uint ulPolicyVersionMinor;
|
|
|
|
/// <summary>Length of the assembly directory name in bytes.</summary>
|
|
public uint ulAssemblyDirectoryNameLength;
|
|
|
|
/// <summary>Pointer to a null-terminated string that contains a textually-encoded format of the assembly's identity.</summary>
|
|
[MarshalAs(UnmanagedType.LPWStr)] public string lpAssemblyEncodedAssemblyIdentity;
|
|
|
|
/// <summary>Pointer to a null-terminated string that indicates the original path to this assembly's manifest.</summary>
|
|
[MarshalAs(UnmanagedType.LPWStr)] public string lpAssemblyManifestPath;
|
|
|
|
/// <summary>
|
|
/// Pointer to a null-terminated string that indicates the path of whatever policy assembly was used to determine that this
|
|
/// version of the assembly should be loaded. If this member is null, no policy was used to decide to load this version.
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.LPWStr)] public string lpAssemblyPolicyPath;
|
|
|
|
/// <summary>Pointer to a null-terminated string that indicates the folder from which this assembly was loaded.</summary>
|
|
[MarshalAs(UnmanagedType.LPWStr)] public string lpAssemblyDirectoryName;
|
|
|
|
/// <summary/>
|
|
public uint ulFileCount;
|
|
}
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct ACTIVATION_CONTEXT_BASIC_INFORMATION
|
|
{
|
|
/// <summary>Undocumented.</summary>
|
|
public HACTCTX hActCtx;
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
public uint dwFlags;
|
|
}
|
|
|
|
/// <summary>The <c>ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION_UNMGD</c> structure is used by the QueryActCtxW function.</summary>
|
|
/// <remarks>
|
|
/// The following example requires Windows Server 2008 R2 or Windows 7 and shows the method to retrieve information about the
|
|
/// compatibility context.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-activation_context_compatibility_information typedef struct
|
|
// _ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION { DWORD ElementCount; COMPATIBILITY_CONTEXT_ELEMENT Elements[]; }
|
|
// ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION, *PACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION;
|
|
[PInvokeData("winnt.h", MSDNShortId = "d8c1ef4a-8e64-45bd-a185-b4af7932a0d2")]
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION_UNMGD
|
|
{
|
|
/// <summary>The number of compatibility elements defined in the application manifest.</summary>
|
|
public uint ElementCount;
|
|
|
|
/// <summary>
|
|
/// This is an array of COMPATIBILITY_CONTEXT_ELEMENT structures. Each structure describes one compatibility element in the
|
|
/// application manifest.
|
|
/// </summary>
|
|
public IntPtr Elements;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION</c> structure is the managed equivalent of the
|
|
/// <c>ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION_UNMGD</c> structure used by the QueryActCtxW function.
|
|
/// </summary>
|
|
public struct ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION
|
|
{
|
|
/// <summary>
|
|
/// This is an array of COMPATIBILITY_CONTEXT_ELEMENT structures. Each structure describes one compatibility element in the
|
|
/// application manifest.
|
|
/// </summary>
|
|
public COMPATIBILITY_CONTEXT_ELEMENT[] Elements;
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION"/> struct.</summary>
|
|
/// <param name="mem">The unmanaged pointer to this info.</param>
|
|
internal ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION(IntPtr mem)
|
|
{
|
|
var c = Marshal.ReadInt32(mem, 0);
|
|
Elements = mem.Offset(4).ToArray<COMPATIBILITY_CONTEXT_ELEMENT>(c);
|
|
}
|
|
}
|
|
|
|
/// <summary>The <c>ACTIVATION_CONTEXT_DETAILED_INFORMATION</c> structure is used by the QueryActCtxW function.</summary>
|
|
/// <remarks>
|
|
/// If QueryActCtxW is called with the ActivationContextDetailedInformation option, and the function succeeds, the information in the
|
|
/// returned buffer is in the form of the <c>ACTIVATION_CONTEXT_DETAILED_INFORMATION</c> structure. The following is an example of a
|
|
/// structure used to hold detailed information about the activation context and a call from <c>QueryActCtxW</c>.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-activation_context_detailed_information typedef struct
|
|
// _ACTIVATION_CONTEXT_DETAILED_INFORMATION { DWORD dwFlags; DWORD ulFormatVersion; DWORD ulAssemblyCount; DWORD
|
|
// ulRootManifestPathType; DWORD ulRootManifestPathChars; DWORD ulRootConfigurationPathType; DWORD ulRootConfigurationPathChars;
|
|
// DWORD ulAppDirPathType; DWORD ulAppDirPathChars; PCWSTR lpRootManifestPath; PCWSTR lpRootConfigurationPath; PCWSTR lpAppDirPath; }
|
|
// ACTIVATION_CONTEXT_DETAILED_INFORMATION, *PACTIVATION_CONTEXT_DETAILED_INFORMATION;
|
|
[PInvokeData("winnt.h", MSDNShortId = "58e4acfe-d5c8-45ae-bf32-469229ffc836")]
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
|
|
public struct ACTIVATION_CONTEXT_DETAILED_INFORMATION
|
|
{
|
|
/// <summary>This value is always 0.</summary>
|
|
public uint dwFlags;
|
|
|
|
/// <summary>
|
|
/// This value specifies the format of the returned information. On Windows XP and Windows Server 2003 this member is always 1.
|
|
/// </summary>
|
|
public uint ulFormatVersion;
|
|
|
|
/// <summary>Number of assemblies in the activation context.</summary>
|
|
public uint ulAssemblyCount;
|
|
|
|
/// <summary>
|
|
/// <para>Specifies the kind of path from which this assembly's manifest was loaded.</para>
|
|
/// <para>This member is always one of the following constants:</para>
|
|
/// </summary>
|
|
public uint ulRootManifestPathType;
|
|
|
|
/// <summary>Number of characters in the manifest path.</summary>
|
|
public uint ulRootManifestPathChars;
|
|
|
|
/// <summary>
|
|
/// <para>Specifies the kind of path from which this assembly's application configuration manifest was loaded.</para>
|
|
/// <para>This member is always one of the following constants:</para>
|
|
/// </summary>
|
|
public uint ulRootConfigurationPathType;
|
|
|
|
/// <summary>Number of characters in any application configuration file path.</summary>
|
|
public uint ulRootConfigurationPathChars;
|
|
|
|
/// <summary>
|
|
/// <para>Specifies the kind of path from which this application manifest was loaded.</para>
|
|
/// <para>This member is always one of the following constants:</para>
|
|
/// </summary>
|
|
public uint ulAppDirPathType;
|
|
|
|
/// <summary>Number of characters in the application directory.</summary>
|
|
public uint ulAppDirPathChars;
|
|
|
|
/// <summary>Path of the application manifest.</summary>
|
|
[MarshalAs(UnmanagedType.LPWStr)] public string lpRootManifestPath;
|
|
|
|
/// <summary>Path of the configuration file.</summary>
|
|
[MarshalAs(UnmanagedType.LPWStr)] public string lpRootConfigurationPath;
|
|
|
|
/// <summary>Path of the application directory.</summary>
|
|
[MarshalAs(UnmanagedType.LPWStr)] public string lpAppDirPath;
|
|
}
|
|
|
|
/// <summary>The <c>ACTIVATION_CONTEXT_QUERY_INDEX</c> structure is used by QueryActCtxW function.</summary>
|
|
/// <remarks>
|
|
/// Calling the QueryActCtxW function with the FileInformationInAssemblyOfAssemblyInActivationContext option requires that the
|
|
/// pvSubInstance parameter point to an <c>ACTIVATION_CONTEXT_QUERY_INDEX</c> structure. See the sample for
|
|
/// ASSEMBLY_FILE_DETAILED_INFORMATION for an example of its use.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-activation_context_query_index typedef struct
|
|
// _ACTIVATION_CONTEXT_QUERY_INDEX { DWORD ulAssemblyIndex; DWORD ulFileIndexInAssembly; } ACTIVATION_CONTEXT_QUERY_INDEX, *PACTIVATION_CONTEXT_QUERY_INDEX;
|
|
[PInvokeData("winnt.h", MSDNShortId = "eb15895c-07c9-4b68-83ef-2f2b8e3b271c")]
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct ACTIVATION_CONTEXT_QUERY_INDEX
|
|
{
|
|
/// <summary>One-based index of the assembly whose file table is to be queried.</summary>
|
|
public uint ulAssemblyIndex;
|
|
|
|
/// <summary>Zero-based index of the file in the above assembly to be queried.</summary>
|
|
public uint ulFileIndexInAssembly;
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="ACTIVATION_CONTEXT_QUERY_INDEX"/> struct.</summary>
|
|
/// <param name="asmIndex">One-based index of the assembly whose file table is to be queried.</param>
|
|
/// <param name="fileIndex">Zero-based index of the file in the above assembly to be queried.</param>
|
|
public ACTIVATION_CONTEXT_QUERY_INDEX(uint asmIndex, uint fileIndex)
|
|
{
|
|
ulAssemblyIndex = asmIndex;
|
|
ulFileIndexInAssembly = fileIndex;
|
|
}
|
|
}
|
|
|
|
/// <summary>The <c>ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION</c> structure is used by the QueryActCtxW function.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-activation_context_run_level_information typedef struct
|
|
// _ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION { DWORD ulFlags; ACTCTX_REQUESTED_RUN_LEVEL RunLevel; DWORD UiAccess; }
|
|
// ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION, *PACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION;
|
|
[PInvokeData("winnt.h", MSDNShortId = "1c4e7333-6982-4d58-ab2a-d1993c59d0ef")]
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION
|
|
{
|
|
/// <summary>This parameter is reserved for future use. This parameter currently returns 0.</summary>
|
|
public uint ulFlags;
|
|
|
|
/// <summary>A ACTCTX_REQUESTED_RUN_LEVEL enumeration value that gives the requested run level of the activation context.</summary>
|
|
public ACTCTX_REQUESTED_RUN_LEVEL RunLevel;
|
|
|
|
/// <summary>
|
|
/// This parameter returns zero if the <c>uiAccess</c> attribute in the application manifest is false. This parameter returns a
|
|
/// non-zero value if the <c>uiAccess</c> attribute in the manifest is true. True means that UI accessibility applications
|
|
/// require access higher privileges.
|
|
/// </summary>
|
|
public uint UiAccess;
|
|
}
|
|
|
|
/// <summary>The <c>ASSEMBLY_FILE_DETAILED_INFORMATION</c> structure is used by the QueryActCtxW function.</summary>
|
|
/// <remarks>
|
|
/// If QueryActCtxW is called with the FileInformationInAssemblyOfAssemblyInActivationContext option, and the function succeeds, the
|
|
/// information in the returned buffer is in form of the <c>ASSEMBLY_FILE_DETAILED_INFORMATION</c> structure. The following is an
|
|
/// example of a structure used to hold detailed information about the activation context and a call from <c>QueryActCtxW</c>.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-_assembly_file_detailed_information typedef struct
|
|
// _ASSEMBLY_FILE_DETAILED_INFORMATION { DWORD ulFlags; DWORD ulFilenameLength; DWORD ulPathLength; PCWSTR lpFileName; PCWSTR
|
|
// lpFilePath; } ASSEMBLY_FILE_DETAILED_INFORMATION, *PASSEMBLY_FILE_DETAILED_INFORMATION;
|
|
[PInvokeData("winnt.h", MSDNShortId = "7f1e5155-a6c1-4b6a-be47-37fab337186c")]
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
|
|
public struct ASSEMBLY_FILE_DETAILED_INFORMATION
|
|
{
|
|
/// <summary>This value is always 0.</summary>
|
|
public uint ulFlags;
|
|
|
|
/// <summary>
|
|
/// Length in bytes of the file name pointed to by <c>lpFileName</c>. The count does not include the terminating null character.
|
|
/// </summary>
|
|
public uint ulFilenameLength;
|
|
|
|
/// <summary>
|
|
/// Length in bytes of the path string pointed to by <c>lpFilePath</c> The count does not include the terminating null character.
|
|
/// </summary>
|
|
public uint ulPathLength;
|
|
|
|
/// <summary>Null-terminated string that specifies the name of the file.</summary>
|
|
[MarshalAs(UnmanagedType.LPWStr)] public string lpFileName;
|
|
|
|
/// <summary>Null-terminated string that specifies the path to the file named in <c>lpFileName</c>.</summary>
|
|
[MarshalAs(UnmanagedType.LPWStr)] public string lpFilePath;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>COMPATIBILITY_CONTEXT_ELEMENT</c> structure is used by the QueryActCtxW function as part of the
|
|
/// ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION structure.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-_compatibility_context_element typedef struct
|
|
// _COMPATIBILITY_CONTEXT_ELEMENT { GUID Id; ACTCTX_COMPATIBILITY_ELEMENT_TYPE Type; } COMPATIBILITY_CONTEXT_ELEMENT, *PCOMPATIBILITY_CONTEXT_ELEMENT;
|
|
[PInvokeData("winnt.h", MSDNShortId = "3e654f44-43f6-4282-b277-14ed6e25abf2")]
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct COMPATIBILITY_CONTEXT_ELEMENT
|
|
{
|
|
/// <summary>
|
|
/// <para>This is a <c>GUID</c> that specifies a version of Windows.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>{e2011457-1546-43c5-a5fe-008deee3d3f0}</term>
|
|
/// <term>Windows Vista</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>{35138b9a-5d96-4fbd-8e2d-a2440225f93a}</term>
|
|
/// <term>Windows 7</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </summary>
|
|
public Guid Id;
|
|
|
|
/// <summary>
|
|
/// A value of the ACTCTX_COMPATIBILITY_ELEMENT_TYPE enumeration that describes the compatibility elements in the application manifest.
|
|
/// </summary>
|
|
public ACTCTX_COMPATIBILITY_ELEMENT_TYPE Type;
|
|
}
|
|
|
|
/// <summary>Provides a handle to an account context.</summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct HACTCTX
|
|
{
|
|
private IntPtr handle;
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="HACTCTX"/> struct.</summary>
|
|
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
|
public HACTCTX(IntPtr preexistingHandle) => handle = preexistingHandle;
|
|
|
|
/// <summary>Returns an invalid handle by instantiating a <see cref="HACTCTX"/> object with <see cref="IntPtr.Zero"/>.</summary>
|
|
public static HACTCTX NULL => new HACTCTX(IntPtr.Zero);
|
|
|
|
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
|
|
public bool IsNull => handle == IntPtr.Zero;
|
|
|
|
/// <summary>Performs an explicit conversion from <see cref="HACTCTX"/> to <see cref="IntPtr"/>.</summary>
|
|
/// <param name="h">The handle.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static explicit operator IntPtr(HACTCTX h) => h.handle;
|
|
|
|
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="HACTCTX"/>.</summary>
|
|
/// <param name="h">The pointer to a handle.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static implicit operator HACTCTX(IntPtr h) => new HACTCTX(h);
|
|
|
|
/// <summary>Implements the operator !=.</summary>
|
|
/// <param name="h1">The first handle.</param>
|
|
/// <param name="h2">The second handle.</param>
|
|
/// <returns>The result of the operator.</returns>
|
|
public static bool operator !=(HACTCTX h1, HACTCTX h2) => !(h1 == h2);
|
|
|
|
/// <summary>Implements the operator ==.</summary>
|
|
/// <param name="h1">The first handle.</param>
|
|
/// <param name="h2">The second handle.</param>
|
|
/// <returns>The result of the operator.</returns>
|
|
public static bool operator ==(HACTCTX h1, HACTCTX h2) => h1.Equals(h2);
|
|
|
|
/// <inheritdoc/>
|
|
public override bool Equals(object obj) => obj is HACTCTX h ? handle == h.handle : false;
|
|
|
|
/// <inheritdoc/>
|
|
public override int GetHashCode() => handle.GetHashCode();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Provides a <see cref="SafeHandle"/> to an account context that releases a created HACTCTX instance at disposal using ReleaseActCtx.
|
|
/// </summary>
|
|
public class SafeHACTCTX : SafeHANDLE
|
|
{
|
|
/// <summary>Initializes a new instance of the <see cref="HACTCTX"/> class and assigns an existing handle.</summary>
|
|
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
|
/// <param name="ownsHandle">
|
|
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
|
|
/// </param>
|
|
public SafeHACTCTX(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { }
|
|
|
|
private SafeHACTCTX() : base()
|
|
{
|
|
}
|
|
|
|
/// <summary>Gets the handle to the active activation context of the calling thread.</summary>
|
|
public static SafeHACTCTX GetCurrent()
|
|
{
|
|
if (!GetCurrentActCtx(out var h))
|
|
Win32Error.ThrowLastError();
|
|
return new SafeHACTCTX((IntPtr)h, false);
|
|
}
|
|
|
|
/// <summary>Represents a NULL value.</summary>
|
|
public static HACTCTX Null => new SafeHACTCTX(IntPtr.Zero, false);
|
|
|
|
/// <summary>Performs an implicit conversion from <see cref="SafeHACTCTX"/> to <see cref="HACTCTX"/>.</summary>
|
|
/// <param name="h">The safe handle instance.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static implicit operator HACTCTX(SafeHACTCTX h) => h.handle;
|
|
|
|
/// <inheritdoc/>
|
|
protected override bool InternalReleaseHandle() { ReleaseActCtx(this); return true; }
|
|
}
|
|
}
|
|
} |