From b531dfc6fa0a50f106f16e0c34e7020416373f9c Mon Sep 17 00:00:00 2001 From: David Hall Date: Wed, 17 Jul 2019 20:36:43 -0600 Subject: [PATCH] Added functions from versionhelpers.h --- PInvoke/Kernel32/VersionHelpers.cs | 378 +++++++++++++++++++++++++++++++++++++ 1 file changed, 378 insertions(+) create mode 100644 PInvoke/Kernel32/VersionHelpers.cs diff --git a/PInvoke/Kernel32/VersionHelpers.cs b/PInvoke/Kernel32/VersionHelpers.cs new file mode 100644 index 00000000..7d9e5804 --- /dev/null +++ b/PInvoke/Kernel32/VersionHelpers.cs @@ -0,0 +1,378 @@ +namespace Vanara.PInvoke +{ + public static partial class Kernel32 + { + /// Undocumented, but verifies that + /// + [PInvokeData("versionhelpers.h")] + public static bool IsActiveSessionCountLimited() + { + var VersionInfo = OSVERSIONINFOEX.Default; + VersionInfo.wSuiteMask = SuiteMask.VER_SUITE_TERMINAL; + + var dwlConditionMask = VerSetConditionMask(0, VERSION_MASK.VER_SUITENAME, VERSION_CONDITION.VER_AND); + var fSuiteTerminal = VerifyVersionInfo(ref VersionInfo, VERSION_MASK.VER_SUITENAME, dwlConditionMask); + + VersionInfo.wSuiteMask = SuiteMask.VER_SUITE_SINGLEUSERTS; + var fSuiteSingleUserTS = VerifyVersionInfo(ref VersionInfo, VERSION_MASK.VER_SUITENAME, dwlConditionMask); + + return !(fSuiteTerminal & !fSuiteSingleUserTS); + } + + /// Indicates if the current OS version matches, or is greater than, the Windows 10 version. + /// True if the current OS version matches, or is greater than, the Windows 10 version; otherwise, false. + /// + /// + /// Applications not manifested for Windows 10 return false, even if the current operating system version is Windows 10. To manifest + /// your applications for Windows 10, see Targeting your application for Windows. + /// + /// + /// The version helper functions do not differentiate between client and server releases. They return true if the current OS + /// version number is equal to or higher than the version of the client named in the call. For example, a call to + /// IsWindowsXPSP3OrGreater will return true on Windows Server 2008. Applications that need to distinguish between server and + /// client versions of Windows should call IsWindowsServer. + /// + /// + /// For situations where a Windows Server version number isn't shared with a Windows client release, you can use + /// IsWindowsVersionOrGreater to confirm. + /// + /// Examples + /// + /// The inline functions defined in the VersionHelpers.h header file let you verify the operating system version by returning + /// a Boolean value when testing for a version of Windows. + /// + /// For example, if your application requires Windows 10 or later, use the following test. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/versionhelpers/nf-versionhelpers-iswindows10orgreater VERSIONHELPERAPI + // IsWindows10OrGreater( ); + [PInvokeData("versionhelpers.h", MSDNShortId = "1F7AE6CA-3E2B-4DF1-A047-58AB9A0B1DA4")] + public static bool IsWindows10OrGreater() => IsWindowsVersionOrGreater(Macros.HIBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WIN10), Macros.LOBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WIN10), 0); + + /// Indicates if the current OS version matches, or is greater than, the Windows 7 version. + /// True if the current OS version matches, or is greater than, the Windows 7 version; otherwise, false. + /// + /// + /// This function does not differentiate between client and server releases. It will return true if the current OS version + /// number is equal to or higher than the version of the client named in the call. For example, a call to IsWindowsXPSP3OrGreater + /// will return true on Windows Server 2008. Applications that need to distinguish between server and client versions of + /// Windows should call IsWindowsServer. + /// + /// + /// For situations where a Windows Server version number isn't shared with a Windows client release, you can use + /// IsWindowsVersionOrGreater to confirm. + /// + /// Examples + /// + /// The inline functions defined in the VersionHelpers.h header file let you verify the operating system version by returning + /// a Boolean value when testing for a version of Windows. + /// + /// For example, if your application requires Windows 7 or later, use the following test. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/versionhelpers/nf-versionhelpers-iswindows7orgreater VERSIONHELPERAPI + // IsWindows7OrGreater( ); + [PInvokeData("versionhelpers.h", MSDNShortId = "5C475B5E-1412-4F60-AB81-00BE83E204BF")] + public static bool IsWindows7OrGreater() => IsWindowsVersionOrGreater(Macros.HIBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WIN7), Macros.LOBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WIN7), 0); + + /// Indicates if the current OS version matches, or is greater than, the Windows 7 with Service Pack 1 (SP1) version. + /// True if the current OS version matches, or is greater than, the Windows 7 with SP1 version; otherwise, false. + /// + /// + /// This function does not differentiate between client and server releases. It will return true if the current OS version + /// number is equal to or higher than the version of the client named in the call. For example, a call to IsWindowsXPSP3OrGreater + /// will return true on Windows Server 2008. Applications that need to distinguish between server and client versions of + /// Windows should call IsWindowsServer. + /// + /// + /// For situations where a Windows Server version number isn't shared with a Windows client release, you can use + /// IsWindowsVersionOrGreater to confirm. + /// + /// Examples + /// + /// The inline functions defined in the VersionHelpers.h header file let you verify the operating system version by returning + /// a Boolean value when testing for a version of Windows. + /// + /// For example, if your application requires Windows 7 with SP1 or later, use the following test. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/versionhelpers/nf-versionhelpers-iswindows7sp1orgreater VERSIONHELPERAPI + // IsWindows7SP1OrGreater( ); + [PInvokeData("versionhelpers.h", MSDNShortId = "E8AD3423-91EF-4ECE-9EF2-808C68CEA861")] + public static bool IsWindows7SP1OrGreater() => IsWindowsVersionOrGreater(Macros.HIBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WIN7), Macros.LOBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WIN7), 1); + + /// Indicates if the current OS version matches, or is greater than, the Windows 8 version. + /// True if the current OS version matches, or is greater than, the Windows 8 version; otherwise, false. + /// + /// + /// This function does not differentiate between client and server releases. It will return true if the current OS version + /// number is equal to or higher than the version of the client named in the call. For example, a call to IsWindowsXPSP3OrGreater + /// will return true on Windows Server 2008. Applications that need to distinguish between server and client versions of + /// Windows should call IsWindowsServer. + /// + /// + /// For situations where a Windows Server version number isn't shared with a Windows client release, you can use + /// IsWindowsVersionOrGreater to confirm. + /// + /// Examples + /// + /// The inline functions defined in the VersionHelpers.h header file let you verify the operating system version by returning + /// a Boolean value when testing for a version of Windows. + /// + /// For example, if your application requires Windows 8 or later, use the following test. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/versionhelpers/nf-versionhelpers-iswindows8orgreater VERSIONHELPERAPI + // IsWindows8OrGreater( ); + [PInvokeData("versionhelpers.h", MSDNShortId = "D11971C8-2E8F-4AD2-BE0B-FEFEC8949125")] + public static bool IsWindows8OrGreater() => IsWindowsVersionOrGreater(Macros.HIBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WIN8), Macros.LOBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WIN8), 0); + + /// Indicates if the current OS version matches, or is greater than, the Windows 8.1 version. + /// True if the current OS version matches, or is greater than, the Windows 8.1 version; otherwise, false. + /// + /// + /// Applications not manifested for Windows 8.1 or Windows 10 return false, even if the current operating system version is Windows + /// 8.1 or Windows 10. To manifest your applications for Windows 8.1 or Windows 10, see Targeting your application for Windows. + /// + /// + /// This function does not differentiate between client and server releases. It will return true if the current OS version + /// number is equal to or higher than the version of the client named in the call. For example, a call to IsWindowsXPSP3OrGreater + /// will return true on Windows Server 2008. Applications that need to distinguish between server and client versions of + /// Windows should call IsWindowsServer. + /// + /// + /// For situations where a Windows Server version number isn't shared with a Windows client release, you can use + /// IsWindowsVersionOrGreater to confirm. + /// + /// Examples + /// + /// The inline functions defined in the VersionHelpers.h header file let you verify the operating system version by returning + /// a Boolean value when testing for a version of Windows. + /// + /// For example, if your application requires Windows 8.1 or later, use the following test. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/versionhelpers/nf-versionhelpers-iswindows8point1orgreater VERSIONHELPERAPI + // IsWindows8Point1OrGreater( ); + [PInvokeData("versionhelpers.h", MSDNShortId = "E391B568-5E43-42C7-B186-8CA524331FFE")] + public static bool IsWindows8Point1OrGreater() => IsWindowsVersionOrGreater(Macros.HIBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WINBLUE), Macros.LOBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WINBLUE), 0); + + /// + /// Indicates if the current OS is a Windows Server release. Applications that need to distinguish between server and client versions + /// of Windows should call this function. + /// + /// True if the current OS is a Windows Server version; otherwise, false. + // https://docs.microsoft.com/en-us/windows/win32/api/versionhelpers/nf-versionhelpers-iswindowsserver VERSIONHELPERAPI + // IsWindowsServer( ); + [PInvokeData("versionhelpers.h", MSDNShortId = "7CC1DD25-762B-489F-AC20-1B57764923A2")] + public static bool IsWindowsServer() + { + var osvi = OSVERSIONINFOEX.Default; + osvi.wProductType = ProductType.VER_NT_WORKSTATION; + + var dwlConditionMask = VerSetConditionMask(0, VERSION_MASK.VER_PRODUCT_TYPE, VERSION_CONDITION.VER_EQUAL); + + return !VerifyVersionInfo(ref osvi, VERSION_MASK.VER_PRODUCT_TYPE, dwlConditionMask); + } + + /// Indicates if the current OS version matches, or is greater than, the most recent Windows version. + /// True if the current OS version matches, or is greater than, the most recent Windows version; otherwise, false. + [PInvokeData("versionhelpers.h")] + public static bool IsWindowsThresholdOrGreater() => IsWindowsVersionOrGreater(Macros.HIBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WINTHRESHOLD), Macros.LOBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WINTHRESHOLD), 0); + + /// + /// Indicates if the current OS version matches, or is greater than, the provided version information. This function is useful in + /// confirming a version of Windows Server that doesn't share a version number with a client release. + /// + /// The major OS version number. + /// The minor OS version number. + /// The major Service Pack version number. + /// + /// TRUE if the specified version matches, or is greater than, the version of the current Windows OS; otherwise, FALSE. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/versionhelpers/nf-versionhelpers-iswindowsversionorgreater VERSIONHELPERAPI + // IsWindowsVersionOrGreater( WORD wMajorVersion, WORD wMinorVersion, WORD wServicePackMajor ); + [PInvokeData("versionhelpers.h", MSDNShortId = "B28DFEC0-A94E-49F6-9DF0-4EE470EC4AF5")] + public static bool IsWindowsVersionOrGreater(ushort wMajorVersion, ushort wMinorVersion, ushort wServicePackMajor) + { + var osvi = OSVERSIONINFOEX.Default; + osvi.dwMajorVersion = wMajorVersion; + osvi.dwMinorVersion = wMinorVersion; + osvi.wServicePackMajor = wServicePackMajor; + + var dwlConditionMask = VerSetConditionMask(VerSetConditionMask(VerSetConditionMask(0, VERSION_MASK.VER_MAJORVERSION, VERSION_CONDITION.VER_GREATER_EQUAL), VERSION_MASK.VER_MINORVERSION, VERSION_CONDITION.VER_GREATER_EQUAL), VERSION_MASK.VER_SERVICEPACKMAJOR, VERSION_CONDITION.VER_GREATER_EQUAL); + + return VerifyVersionInfo(ref osvi, VERSION_MASK.VER_MAJORVERSION | VERSION_MASK.VER_MINORVERSION | VERSION_MASK.VER_SERVICEPACKMAJOR, dwlConditionMask); + } + + /// Indicates if the current OS version matches, or is greater than, the Windows Vista version. + /// True if the current OS version matches, or is greater than, the Windows Vista version; otherwise, false. + /// + /// + /// This function does not differentiate between client and server releases. It will return true if the current OS version + /// number is equal to or higher than the version of the client named in the call. For example, a call to IsWindowsXPSP3OrGreater + /// will return true on Windows Server 2008. Applications that need to distinguish between server and client versions of + /// Windows should call IsWindowsServer. + /// + /// + /// For situations where a Windows Server version number isn't shared with a Windows client release, you can use + /// IsWindowsVersionOrGreater to confirm. + /// + /// Examples + /// + /// The inline functions defined in the VersionHelpers.h header file let you verify the operating system version by returning + /// a Boolean value when testing for a version of Windows. + /// + /// For example, if your application requires Windows Vista or later, use the following test. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/versionhelpers/nf-versionhelpers-iswindowsvistaorgreater VERSIONHELPERAPI + // IsWindowsVistaOrGreater( ); + [PInvokeData("versionhelpers.h", MSDNShortId = "556C70DC-6A44-4D85-BDBF-C1110D63DC69")] + public static bool IsWindowsVistaOrGreater() => IsWindowsVersionOrGreater(Macros.HIBYTE((ushort)WIN32_WINNT._WIN32_WINNT_VISTA), Macros.LOBYTE((ushort)WIN32_WINNT._WIN32_WINNT_VISTA), 0); + + /// Indicates if the current OS version matches, or is greater than, the Windows Vista with Service Pack 1 (SP1) version. + /// True if the current OS version matches, or is greater than, the Windows Vista with SP1 version; otherwise, false. + /// + /// + /// This function does not differentiate between client and server releases. It will return true if the current OS version + /// number is equal to or higher than the version of the client named in the call. For example, a call to IsWindowsXPSP3OrGreater + /// will return true on Windows Server 2008. Applications that need to distinguish between server and client versions of + /// Windows should call IsWindowsServer. + /// + /// + /// For situations where a Windows Server version number isn't shared with a Windows client release, you can use + /// IsWindowsVersionOrGreater to confirm. + /// + /// Examples + /// + /// The inline functions defined in the VersionHelpers.h header file let you verify the operating system version by returning + /// a Boolean value when testing for a version of Windows. + /// + /// For example, if your application requires Windows Vista with SP1 or later, use the following test. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/versionhelpers/nf-versionhelpers-iswindowsvistasp1orgreater VERSIONHELPERAPI + // IsWindowsVistaSP1OrGreater( ); + [PInvokeData("versionhelpers.h", MSDNShortId = "7E74A761-E336-4618-B92F-166C3DF1FF66")] + public static bool IsWindowsVistaSP1OrGreater() => IsWindowsVersionOrGreater(Macros.HIBYTE((ushort)WIN32_WINNT._WIN32_WINNT_VISTA), Macros.LOBYTE((ushort)WIN32_WINNT._WIN32_WINNT_VISTA), 1); + + /// Indicates if the current OS version matches, or is greater than, the Windows Vista with Service Pack 2 (SP2) version. + /// True if the current OS version matches, or is greater than, the Windows Vista with SP2 version; otherwise, false. + /// + /// + /// This function does not differentiate between client and server releases. It will return true if the current OS version + /// number is equal to or higher than the version of the client named in the call. For example, a call to IsWindowsXPSP3OrGreater + /// will return true on Windows Server 2008. Applications that need to distinguish between server and client versions of + /// Windows should call IsWindowsServer. + /// + /// + /// For situations where a Windows Server version number isn't shared with a Windows client release, you can use + /// IsWindowsVersionOrGreater to confirm. + /// + /// Examples + /// + /// The inline functions defined in the VersionHelpers.h header file let you verify the operating system version by returning + /// a Boolean value when testing for a version of Windows. + /// + /// For example, if your application requires Windows Vista with SP2 or later, use the following test. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/versionhelpers/nf-versionhelpers-iswindowsvistasp2orgreater VERSIONHELPERAPI + // IsWindowsVistaSP2OrGreater( ); + [PInvokeData("versionhelpers.h", MSDNShortId = "8D7F5DA2-8927-4453-A5E3-35A345B099EC")] + public static bool IsWindowsVistaSP2OrGreater() => IsWindowsVersionOrGreater(Macros.HIBYTE((ushort)WIN32_WINNT._WIN32_WINNT_VISTA), Macros.LOBYTE((ushort)WIN32_WINNT._WIN32_WINNT_VISTA), 2); + + /// Indicates if the current OS version matches, or is greater than, the Windows XP version. + /// True if the current OS version matches, or is greater than, the Windows XP version; otherwise, false. + /// + /// + /// This function does not differentiate between client and server releases. It will return true if the current OS version + /// number is equal to or higher than the version of the client named in the call. For example, a call to IsWindowsXPSP3OrGreater + /// will return true on Windows Server 2008. Applications that need to distinguish between server and client versions of + /// Windows should call IsWindowsServer. + /// + /// + /// For situations where a Windows Server version number isn't shared with a Windows client release, you can use + /// IsWindowsVersionOrGreater to confirm. + /// + /// Examples + /// + /// The inline functions defined in the VersionHelpers.h header file let you verify the operating system version by returning + /// a Boolean value when testing for a version of Windows. + /// + /// For example, if your application requires Windows XP or later, use the following test. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/versionhelpers/nf-versionhelpers-iswindowsxporgreater VERSIONHELPERAPI + // IsWindowsXPOrGreater( ); + [PInvokeData("versionhelpers.h", MSDNShortId = "48B7FAD6-569F-4CF5-A413-857679363736")] + public static bool IsWindowsXPOrGreater() => IsWindowsVersionOrGreater(Macros.HIBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WINXP), Macros.LOBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WINXP), 0); + + /// Indicates if the current OS version matches, or is greater than, the Windows XP with Service Pack 1 (SP1) version. + /// True if the current OS version matches, or is greater than, the Windows XP with SP1 version; otherwise, false. + /// + /// + /// This function does not differentiate between client and server releases. It will return true if the current OS version + /// number is equal to or higher than the version of the client named in the call. For example, a call to IsWindowsXPSP3OrGreater + /// will return true on Windows Server 2008. Applications that need to distinguish between server and client versions of + /// Windows should call IsWindowsServer. + /// + /// + /// For situations where a Windows Server version number isn't shared with a Windows client release, you can use + /// IsWindowsVersionOrGreater to confirm. + /// + /// Examples + /// + /// The inline functions defined in the VersionHelpers.h header file let you verify the operating system version by returning + /// a Boolean value when testing for a version of Windows. + /// + /// For example, if your application requires Windows XP with SP1 or later, use the following test. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/versionhelpers/nf-versionhelpers-iswindowsxpsp1orgreater VERSIONHELPERAPI + // IsWindowsXPSP1OrGreater( ); + [PInvokeData("versionhelpers.h", MSDNShortId = "F8921444-B13D-4522-84F2-4792F4F37EA5")] + public static bool IsWindowsXPSP1OrGreater() => IsWindowsVersionOrGreater(Macros.HIBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WINXP), Macros.LOBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WINXP), 1); + + /// Indicates if the current OS version matches, or is greater than, the Windows XP with Service Pack 2 (SP2) version. + /// True if the current OS version matches, or is greater than, the Windows XP with SP2 version number; otherwise, false. + /// + /// + /// This function does not differentiate between client and server releases. It will return true if the current OS version + /// number is equal to or higher than the version of the client named in the call. For example, a call to IsWindowsXPSP3OrGreater + /// will return true on Windows Server 2008. Applications that need to distinguish between server and client versions of + /// Windows should call IsWindowsServer. + /// + /// + /// For situations where a Windows Server version number isn't shared with a Windows client release, you can use + /// IsWindowsVersionOrGreater to confirm. + /// + /// Examples + /// + /// The inline functions defined in the VersionHelpers.h header file let you verify the operating system version by returning + /// a Boolean value when testing for a version of Windows. + /// + /// For example, if your application requires Windows XP with SP2 or later, use the following test. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/versionhelpers/nf-versionhelpers-iswindowsxpsp2orgreater VERSIONHELPERAPI + // IsWindowsXPSP2OrGreater( ); + [PInvokeData("versionhelpers.h", MSDNShortId = "DA957BA8-AD28-4096-8BE5-B77CA55B9324")] + public static bool IsWindowsXPSP2OrGreater() => IsWindowsVersionOrGreater(Macros.HIBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WINXP), Macros.LOBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WINXP), 2); + + /// Indicates if the current OS version matches, or is greater than, the Windows XP with Service Pack 3 (SP3) version. + /// True if the current OS version matches, or is greater than, the Windows XP with SP3 version; otherwise, false. + /// + /// + /// This function does not differentiate between client and server releases. It will return true if the current OS version + /// number is equal to or higher than the version of the client named in the call. For example, a call to + /// IsWindowsXPSP3OrGreater will return true on Windows Server 2008. Applications that need to distinguish between + /// server and client versions of Windows should call IsWindowsServer. + /// + /// + /// For situations where a Windows Server version number isn't shared with a Windows client release, you can use + /// IsWindowsVersionOrGreater to confirm. + /// + /// Examples + /// + /// The inline functions defined in the VersionHelpers.h header file let you verify the operating system version by returning + /// a Boolean value when testing for a version of Windows. + /// + /// For example, if your application requires Windows XP with SP3 or later, use the following test. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/versionhelpers/nf-versionhelpers-iswindowsxpsp3orgreater VERSIONHELPERAPI + // IsWindowsXPSP3OrGreater( ); + [PInvokeData("versionhelpers.h", MSDNShortId = "06DC8FF0-8652-4652-855F-600AC53C6301")] + public static bool IsWindowsXPSP3OrGreater() => IsWindowsVersionOrGreater(Macros.HIBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WINXP), Macros.LOBYTE((ushort)WIN32_WINNT._WIN32_WINNT_WINXP), 3); + } +} \ No newline at end of file