mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-16 17:10:20 -10:00
456 lines
20 KiB
C#
456 lines
20 KiB
C#
// Licensed to the .NET Foundation under one or more agreements.
|
|
// The .NET Foundation licenses this file to you under the MIT license.
|
|
// See the LICENSE file in the project root for more information.
|
|
|
|
using System.Collections;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using Internal.Win32;
|
|
|
|
namespace System
|
|
{
|
|
public static partial class Environment
|
|
{
|
|
internal static bool IsWindows8OrAbove => WindowsVersion.IsWindows8OrAbove;
|
|
|
|
private static string? GetEnvironmentVariableFromRegistry(string variable, bool fromMachine)
|
|
{
|
|
Debug.Assert(variable != null);
|
|
|
|
#if FEATURE_APPX
|
|
if (ApplicationModel.IsUap)
|
|
return null; // Systems without the Windows registry pretend that it's always empty.
|
|
#endif
|
|
|
|
using (RegistryKey? environmentKey = OpenEnvironmentKeyIfExists(fromMachine, writable: false))
|
|
{
|
|
return environmentKey?.GetValue(variable) as string;
|
|
}
|
|
}
|
|
|
|
private static void SetEnvironmentVariableFromRegistry(string variable, string? value, bool fromMachine)
|
|
{
|
|
Debug.Assert(variable != null);
|
|
|
|
#if FEATURE_APPX
|
|
if (ApplicationModel.IsUap)
|
|
return; // Systems without the Windows registry pretend that it's always empty.
|
|
#endif
|
|
|
|
const int MaxUserEnvVariableLength = 255; // User-wide env vars stored in the registry have names limited to 255 chars
|
|
if (!fromMachine && variable.Length >= MaxUserEnvVariableLength)
|
|
{
|
|
throw new ArgumentException(SR.Argument_LongEnvVarValue, nameof(variable));
|
|
}
|
|
|
|
using (RegistryKey? environmentKey = OpenEnvironmentKeyIfExists(fromMachine, writable: true))
|
|
{
|
|
if (environmentKey != null)
|
|
{
|
|
if (value == null)
|
|
{
|
|
environmentKey.DeleteValue(variable, throwOnMissingValue: false);
|
|
}
|
|
else
|
|
{
|
|
environmentKey.SetValue(variable, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
// send a WM_SETTINGCHANGE message to all windows
|
|
IntPtr r = Interop.User32.SendMessageTimeout(new IntPtr(Interop.User32.HWND_BROADCAST), Interop.User32.WM_SETTINGCHANGE, IntPtr.Zero, "Environment", 0, 1000, IntPtr.Zero);
|
|
Debug.Assert(r != IntPtr.Zero, "SetEnvironmentVariable failed: " + Marshal.GetLastWin32Error());
|
|
}
|
|
|
|
private static IDictionary GetEnvironmentVariablesFromRegistry(bool fromMachine)
|
|
{
|
|
var results = new Hashtable();
|
|
#if FEATURE_APPX
|
|
if (ApplicationModel.IsUap) // Systems without the Windows registry pretend that it's always empty.
|
|
return results;
|
|
#endif
|
|
|
|
using (RegistryKey? environmentKey = OpenEnvironmentKeyIfExists(fromMachine, writable: false))
|
|
{
|
|
if (environmentKey != null)
|
|
{
|
|
foreach (string name in environmentKey.GetValueNames())
|
|
{
|
|
string? value = environmentKey.GetValue(name, "").ToString();
|
|
try
|
|
{
|
|
results.Add(name, value);
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
// Throw and catch intentionally to provide non-fatal notification about corrupted environment block
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
private static RegistryKey? OpenEnvironmentKeyIfExists(bool fromMachine, bool writable)
|
|
{
|
|
RegistryKey baseKey;
|
|
string keyName;
|
|
|
|
if (fromMachine)
|
|
{
|
|
baseKey = Registry.LocalMachine;
|
|
keyName = @"System\CurrentControlSet\Control\Session Manager\Environment";
|
|
}
|
|
else
|
|
{
|
|
baseKey = Registry.CurrentUser;
|
|
keyName = "Environment";
|
|
}
|
|
|
|
return baseKey.OpenSubKey(keyName, writable: writable);
|
|
}
|
|
|
|
public static string UserName
|
|
{
|
|
get
|
|
{
|
|
#if FEATURE_APPX
|
|
if (ApplicationModel.IsUap)
|
|
return "Windows User";
|
|
#endif
|
|
|
|
// 40 should be enough as we're asking for the SAM compatible name (DOMAIN\User).
|
|
// The max length should be 15 (domain) + 1 (separator) + 20 (name) + null. If for
|
|
// some reason it isn't, we'll grow the buffer.
|
|
|
|
// https://support.microsoft.com/en-us/help/909264/naming-conventions-in-active-directory-for-computers-domains-sites-and
|
|
// https://msdn.microsoft.com/en-us/library/ms679635.aspx
|
|
|
|
var builder = new ValueStringBuilder(stackalloc char[40]);
|
|
GetUserName(ref builder);
|
|
|
|
ReadOnlySpan<char> name = builder.AsSpan();
|
|
int index = name.IndexOf('\\');
|
|
if (index != -1)
|
|
{
|
|
// In the form of DOMAIN\User, cut off DOMAIN\
|
|
name = name.Slice(index + 1);
|
|
}
|
|
|
|
string result = name.ToString();
|
|
builder.Dispose();
|
|
return result;
|
|
}
|
|
}
|
|
|
|
private static void GetUserName(ref ValueStringBuilder builder)
|
|
{
|
|
uint size = 0;
|
|
while (Interop.Secur32.GetUserNameExW(Interop.Secur32.NameSamCompatible, ref builder.GetPinnableReference(), ref size) == Interop.BOOLEAN.FALSE)
|
|
{
|
|
if (Marshal.GetLastWin32Error() == Interop.Errors.ERROR_MORE_DATA)
|
|
{
|
|
builder.EnsureCapacity(checked((int)size));
|
|
}
|
|
else
|
|
{
|
|
builder.Length = 0;
|
|
return;
|
|
}
|
|
}
|
|
|
|
builder.Length = (int)size;
|
|
}
|
|
|
|
public static string UserDomainName
|
|
{
|
|
get
|
|
{
|
|
#if FEATURE_APPX
|
|
if (ApplicationModel.IsUap)
|
|
return "Windows Domain";
|
|
#endif
|
|
|
|
// See the comment in UserName
|
|
var builder = new ValueStringBuilder(stackalloc char[40]);
|
|
GetUserName(ref builder);
|
|
|
|
ReadOnlySpan<char> name = builder.AsSpan();
|
|
int index = name.IndexOf('\\');
|
|
if (index != -1)
|
|
{
|
|
// In the form of DOMAIN\User, cut off \User and return
|
|
builder.Length = index;
|
|
return builder.ToString();
|
|
}
|
|
|
|
// In theory we should never get use out of LookupAccountNameW as the above API should
|
|
// always return what we need. Can't find any clues in the historical sources, however.
|
|
|
|
// Domain names aren't typically long.
|
|
// https://support.microsoft.com/en-us/help/909264/naming-conventions-in-active-directory-for-computers-domains-sites-and
|
|
var domainBuilder = new ValueStringBuilder(stackalloc char[64]);
|
|
uint length = (uint)domainBuilder.Capacity;
|
|
|
|
// This API will fail to return the domain name without a buffer for the SID.
|
|
// SIDs are never over 68 bytes long.
|
|
Span<byte> sid = stackalloc byte[68];
|
|
uint sidLength = 68;
|
|
|
|
while (!Interop.Advapi32.LookupAccountNameW(null, ref builder.GetPinnableReference(), ref MemoryMarshal.GetReference(sid),
|
|
ref sidLength, ref domainBuilder.GetPinnableReference(), ref length, out _))
|
|
{
|
|
int error = Marshal.GetLastWin32Error();
|
|
|
|
// The docs don't call this out clearly, but experimenting shows that the error returned is the following.
|
|
if (error != Interop.Errors.ERROR_INSUFFICIENT_BUFFER)
|
|
{
|
|
throw new InvalidOperationException(Win32Marshal.GetMessage(error));
|
|
}
|
|
|
|
domainBuilder.EnsureCapacity((int)length);
|
|
}
|
|
|
|
builder.Dispose();
|
|
domainBuilder.Length = (int)length;
|
|
return domainBuilder.ToString();
|
|
}
|
|
}
|
|
|
|
private static string GetFolderPathCore(SpecialFolder folder, SpecialFolderOption option)
|
|
{
|
|
#if FEATURE_APPX
|
|
if (ApplicationModel.IsUap)
|
|
return WinRTFolderPaths.GetFolderPath(folder, option);
|
|
#endif
|
|
|
|
// We're using SHGetKnownFolderPath instead of SHGetFolderPath as SHGetFolderPath is
|
|
// capped at MAX_PATH.
|
|
//
|
|
// Because we validate both of the input enums we shouldn't have to care about CSIDL and flag
|
|
// definitions we haven't mapped. If we remove or loosen the checks we'd have to account
|
|
// for mapping here (this includes tweaking as SHGetFolderPath would do).
|
|
//
|
|
// The only SpecialFolderOption defines we have are equivalent to KnownFolderFlags.
|
|
|
|
string folderGuid;
|
|
|
|
switch (folder)
|
|
{
|
|
case SpecialFolder.ApplicationData:
|
|
folderGuid = Interop.Shell32.KnownFolders.RoamingAppData;
|
|
break;
|
|
case SpecialFolder.CommonApplicationData:
|
|
folderGuid = Interop.Shell32.KnownFolders.ProgramData;
|
|
break;
|
|
case SpecialFolder.LocalApplicationData:
|
|
folderGuid = Interop.Shell32.KnownFolders.LocalAppData;
|
|
break;
|
|
case SpecialFolder.Cookies:
|
|
folderGuid = Interop.Shell32.KnownFolders.Cookies;
|
|
break;
|
|
case SpecialFolder.Desktop:
|
|
folderGuid = Interop.Shell32.KnownFolders.Desktop;
|
|
break;
|
|
case SpecialFolder.Favorites:
|
|
folderGuid = Interop.Shell32.KnownFolders.Favorites;
|
|
break;
|
|
case SpecialFolder.History:
|
|
folderGuid = Interop.Shell32.KnownFolders.History;
|
|
break;
|
|
case SpecialFolder.InternetCache:
|
|
folderGuid = Interop.Shell32.KnownFolders.InternetCache;
|
|
break;
|
|
case SpecialFolder.Programs:
|
|
folderGuid = Interop.Shell32.KnownFolders.Programs;
|
|
break;
|
|
case SpecialFolder.MyComputer:
|
|
folderGuid = Interop.Shell32.KnownFolders.ComputerFolder;
|
|
break;
|
|
case SpecialFolder.MyMusic:
|
|
folderGuid = Interop.Shell32.KnownFolders.Music;
|
|
break;
|
|
case SpecialFolder.MyPictures:
|
|
folderGuid = Interop.Shell32.KnownFolders.Pictures;
|
|
break;
|
|
case SpecialFolder.MyVideos:
|
|
folderGuid = Interop.Shell32.KnownFolders.Videos;
|
|
break;
|
|
case SpecialFolder.Recent:
|
|
folderGuid = Interop.Shell32.KnownFolders.Recent;
|
|
break;
|
|
case SpecialFolder.SendTo:
|
|
folderGuid = Interop.Shell32.KnownFolders.SendTo;
|
|
break;
|
|
case SpecialFolder.StartMenu:
|
|
folderGuid = Interop.Shell32.KnownFolders.StartMenu;
|
|
break;
|
|
case SpecialFolder.Startup:
|
|
folderGuid = Interop.Shell32.KnownFolders.Startup;
|
|
break;
|
|
case SpecialFolder.System:
|
|
folderGuid = Interop.Shell32.KnownFolders.System;
|
|
break;
|
|
case SpecialFolder.Templates:
|
|
folderGuid = Interop.Shell32.KnownFolders.Templates;
|
|
break;
|
|
case SpecialFolder.DesktopDirectory:
|
|
folderGuid = Interop.Shell32.KnownFolders.Desktop;
|
|
break;
|
|
case SpecialFolder.Personal:
|
|
// Same as Personal
|
|
// case SpecialFolder.MyDocuments:
|
|
folderGuid = Interop.Shell32.KnownFolders.Documents;
|
|
break;
|
|
case SpecialFolder.ProgramFiles:
|
|
folderGuid = Interop.Shell32.KnownFolders.ProgramFiles;
|
|
break;
|
|
case SpecialFolder.CommonProgramFiles:
|
|
folderGuid = Interop.Shell32.KnownFolders.ProgramFilesCommon;
|
|
break;
|
|
case SpecialFolder.AdminTools:
|
|
folderGuid = Interop.Shell32.KnownFolders.AdminTools;
|
|
break;
|
|
case SpecialFolder.CDBurning:
|
|
folderGuid = Interop.Shell32.KnownFolders.CDBurning;
|
|
break;
|
|
case SpecialFolder.CommonAdminTools:
|
|
folderGuid = Interop.Shell32.KnownFolders.CommonAdminTools;
|
|
break;
|
|
case SpecialFolder.CommonDocuments:
|
|
folderGuid = Interop.Shell32.KnownFolders.PublicDocuments;
|
|
break;
|
|
case SpecialFolder.CommonMusic:
|
|
folderGuid = Interop.Shell32.KnownFolders.PublicMusic;
|
|
break;
|
|
case SpecialFolder.CommonOemLinks:
|
|
folderGuid = Interop.Shell32.KnownFolders.CommonOEMLinks;
|
|
break;
|
|
case SpecialFolder.CommonPictures:
|
|
folderGuid = Interop.Shell32.KnownFolders.PublicPictures;
|
|
break;
|
|
case SpecialFolder.CommonStartMenu:
|
|
folderGuid = Interop.Shell32.KnownFolders.CommonStartMenu;
|
|
break;
|
|
case SpecialFolder.CommonPrograms:
|
|
folderGuid = Interop.Shell32.KnownFolders.CommonPrograms;
|
|
break;
|
|
case SpecialFolder.CommonStartup:
|
|
folderGuid = Interop.Shell32.KnownFolders.CommonStartup;
|
|
break;
|
|
case SpecialFolder.CommonDesktopDirectory:
|
|
folderGuid = Interop.Shell32.KnownFolders.PublicDesktop;
|
|
break;
|
|
case SpecialFolder.CommonTemplates:
|
|
folderGuid = Interop.Shell32.KnownFolders.CommonTemplates;
|
|
break;
|
|
case SpecialFolder.CommonVideos:
|
|
folderGuid = Interop.Shell32.KnownFolders.PublicVideos;
|
|
break;
|
|
case SpecialFolder.Fonts:
|
|
folderGuid = Interop.Shell32.KnownFolders.Fonts;
|
|
break;
|
|
case SpecialFolder.NetworkShortcuts:
|
|
folderGuid = Interop.Shell32.KnownFolders.NetHood;
|
|
break;
|
|
case SpecialFolder.PrinterShortcuts:
|
|
folderGuid = Interop.Shell32.KnownFolders.PrintersFolder;
|
|
break;
|
|
case SpecialFolder.UserProfile:
|
|
folderGuid = Interop.Shell32.KnownFolders.Profile;
|
|
break;
|
|
case SpecialFolder.CommonProgramFilesX86:
|
|
folderGuid = Interop.Shell32.KnownFolders.ProgramFilesCommonX86;
|
|
break;
|
|
case SpecialFolder.ProgramFilesX86:
|
|
folderGuid = Interop.Shell32.KnownFolders.ProgramFilesX86;
|
|
break;
|
|
case SpecialFolder.Resources:
|
|
folderGuid = Interop.Shell32.KnownFolders.ResourceDir;
|
|
break;
|
|
case SpecialFolder.LocalizedResources:
|
|
folderGuid = Interop.Shell32.KnownFolders.LocalizedResourcesDir;
|
|
break;
|
|
case SpecialFolder.SystemX86:
|
|
folderGuid = Interop.Shell32.KnownFolders.SystemX86;
|
|
break;
|
|
case SpecialFolder.Windows:
|
|
folderGuid = Interop.Shell32.KnownFolders.Windows;
|
|
break;
|
|
default:
|
|
return string.Empty;
|
|
}
|
|
|
|
return GetKnownFolderPath(folderGuid, option);
|
|
}
|
|
|
|
private static string GetKnownFolderPath(string folderGuid, SpecialFolderOption option)
|
|
{
|
|
Guid folderId = new Guid(folderGuid);
|
|
|
|
int hr = Interop.Shell32.SHGetKnownFolderPath(folderId, (uint)option, IntPtr.Zero, out string path);
|
|
if (hr != 0) // Not S_OK
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
#if FEATURE_APPX
|
|
private static class WinRTFolderPaths
|
|
{
|
|
private static Func<SpecialFolder, SpecialFolderOption, string>? s_winRTFolderPathsGetFolderPath;
|
|
|
|
public static string GetFolderPath(SpecialFolder folder, SpecialFolderOption option)
|
|
{
|
|
if (s_winRTFolderPathsGetFolderPath == null)
|
|
{
|
|
Type? winRtFolderPathsType = Type.GetType("System.WinRTFolderPaths, System.Runtime.WindowsRuntime, Version=4.0.14.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", throwOnError: false);
|
|
MethodInfo? getFolderPathsMethod = winRtFolderPathsType?.GetMethod("GetFolderPath", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static, null, new Type[] { typeof(SpecialFolder), typeof(SpecialFolderOption) }, null);
|
|
var d = (Func<SpecialFolder, SpecialFolderOption, string>?)getFolderPathsMethod?.CreateDelegate(typeof(Func<SpecialFolder, SpecialFolderOption, string>));
|
|
s_winRTFolderPathsGetFolderPath = d ?? delegate { return string.Empty; };
|
|
}
|
|
|
|
return s_winRTFolderPathsGetFolderPath(folder, option);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Seperate type so a .cctor is not created for Enviroment which then would be triggered during startup
|
|
private static class WindowsVersion
|
|
{
|
|
// Cache the value in static readonly that can be optimized out by the JIT
|
|
internal static readonly bool IsWindows8OrAbove = GetIsWindows8OrAbove();
|
|
|
|
private static bool GetIsWindows8OrAbove()
|
|
{
|
|
ulong conditionMask = Interop.Kernel32.VerSetConditionMask(0, Interop.Kernel32.VER_MAJORVERSION, Interop.Kernel32.VER_GREATER_EQUAL);
|
|
conditionMask = Interop.Kernel32.VerSetConditionMask(conditionMask, Interop.Kernel32.VER_MINORVERSION, Interop.Kernel32.VER_GREATER_EQUAL);
|
|
conditionMask = Interop.Kernel32.VerSetConditionMask(conditionMask, Interop.Kernel32.VER_SERVICEPACKMAJOR, Interop.Kernel32.VER_GREATER_EQUAL);
|
|
conditionMask = Interop.Kernel32.VerSetConditionMask(conditionMask, Interop.Kernel32.VER_SERVICEPACKMINOR, Interop.Kernel32.VER_GREATER_EQUAL);
|
|
|
|
// Windows 8 version is 6.2
|
|
Interop.Kernel32.OSVERSIONINFOEX version = default;
|
|
unsafe
|
|
{
|
|
version.dwOSVersionInfoSize = sizeof(Interop.Kernel32.OSVERSIONINFOEX);
|
|
}
|
|
version.dwMajorVersion = 6;
|
|
version.dwMinorVersion = 2;
|
|
version.wServicePackMajor = 0;
|
|
version.wServicePackMinor = 0;
|
|
|
|
return Interop.Kernel32.VerifyVersionInfoW(ref version,
|
|
Interop.Kernel32.VER_MAJORVERSION | Interop.Kernel32.VER_MINORVERSION | Interop.Kernel32.VER_SERVICEPACKMAJOR | Interop.Kernel32.VER_SERVICEPACKMINOR,
|
|
conditionMask);
|
|
}
|
|
}
|
|
}
|
|
}
|