using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Reflection; using System.Reflection.Emit; using System.Security.Cryptography; using System.Text; using BepInEx.Logging; using Mono.Cecil; namespace BepInEx; /// /// Generic helper properties and methods. /// public static class Utility { private const string TRUSTED_PLATFORM_ASSEMBLIES = "TRUSTED_PLATFORM_ASSEMBLIES"; private static bool? sreEnabled; /// /// Whether current Common Language Runtime supports dynamic method generation using /// namespace. /// public static bool CLRSupportsDynamicAssemblies => CheckSRE(); /// /// An encoding for UTF-8 which does not emit a byte order mark (BOM). /// public static Encoding UTF8NoBom { get; } = new UTF8Encoding(false); private static bool CheckSRE() { try { if (sreEnabled.HasValue) return sreEnabled.Value; // ReSharper disable once AssignNullToNotNullAttribute _ = new CustomAttributeBuilder(null, new object[0]); } catch (PlatformNotSupportedException) { sreEnabled = false; return sreEnabled.Value; } catch (ArgumentNullException) { // Suppress ArgumentNullException } sreEnabled = true; return sreEnabled.Value; } /// /// Try to perform an action. /// /// Action to perform. /// Possible exception that gets returned. /// True, if action succeeded, false if an exception occured. public static bool TryDo(Action action, out Exception exception) { exception = null; try { action(); return true; } catch (Exception e) { exception = e; return false; } } /// /// Combines multiple paths together, as the specific method is not available in .NET 3.5. /// /// The multiple paths to combine together. /// A combined path. public static string CombinePaths(params string[] parts) => parts.Aggregate(Path.Combine); /// /// Returns the parent directory of a path, optionally specifying the amount of levels. /// /// The path to get the parent directory of. /// The amount of levels to traverse. Defaults to 1 /// The parent directory. public static string ParentDirectory(string path, int levels = 1) { for (var i = 0; i < levels; i++) path = Path.GetDirectoryName(path); return path; } /// /// Tries to parse a bool, with a default value if unable to parse. /// /// The string to parse /// The value to return if parsing is unsuccessful. /// Boolean value of input if able to be parsed, otherwise default value. public static bool SafeParseBool(string input, bool defaultValue = false) => bool.TryParse(input, out var result) ? result : defaultValue; /// /// Converts a file path into a UnityEngine.WWW format. /// /// The file path to convert. /// A converted file path. public static string ConvertToWWWFormat(string path) => $"file://{path.Replace('\\', '/')}"; /// /// Indicates whether a specified string is null, empty, or consists only of white-space characters. /// /// The string to test. /// True if the value parameter is null or empty, or if value consists exclusively of white-space characters. public static bool IsNullOrWhiteSpace(this string self) => self == null || self.All(char.IsWhiteSpace); /// /// Sorts a given dependency graph using a direct toposort, reporting possible cyclic dependencies. /// /// Nodes to sort /// Function that maps a node to a collection of its dependencies. /// Type of the node in a dependency graph. /// Collection of nodes sorted in the order of least dependencies to the most. /// Thrown when a cyclic dependency occurs. public static IEnumerable TopologicalSort(IEnumerable nodes, Func> dependencySelector) { var sorted_list = new List(); var visited = new HashSet(); var sorted = new HashSet(); foreach (var input in nodes) { var currentStack = new Stack(); if (!Visit(input, currentStack)) throw new Exception("Cyclic Dependency:\r\n" + currentStack.Select(x => $" - {x}") //append dashes .Aggregate((a, b) => $"{a}\r\n{b}")); //add new lines inbetween } return sorted_list; bool Visit(TNode node, Stack stack) { if (visited.Contains(node)) { if (!sorted.Contains(node)) return false; } else { visited.Add(node); stack.Push(node); if (dependencySelector(node).Any(dep => !Visit(dep, stack))) return false; sorted.Add(node); sorted_list.Add(node); stack.Pop(); } return true; } } /// /// Try to resolve and load the given assembly DLL. /// /// Name of the assembly, of the type . /// Directory to search the assembly from. /// The loaded assembly. /// True, if the assembly was found and loaded. Otherwise, false. public static bool TryResolveDllAssembly(AssemblyName assemblyName, string directory, Func loader, out T assembly) where T : class { assembly = null; var potentialDirectories = new List { directory }; if (!Directory.Exists(directory)) return false; potentialDirectories.AddRange(Directory.GetDirectories(directory, "*", SearchOption.AllDirectories)); foreach (var subDirectory in potentialDirectories) { var potentialPaths = new[] { $"{assemblyName.Name}.dll", $"{assemblyName.Name}.exe" }; foreach (var potentialPath in potentialPaths) { var path = Path.Combine(subDirectory, potentialPath); if (!File.Exists(path)) continue; try { assembly = loader(path); } catch (Exception) { continue; } return true; } } return false; } /// /// Checks whether a given cecil type definition is a subtype of a provided type. /// /// Cecil type definition /// Type to check against /// Whether the given cecil type is a subtype of the type. public static bool IsSubtypeOf(this TypeDefinition self, Type td) { if (self.FullName == td.FullName) return true; return self.FullName != "System.Object" && (self.BaseType?.Resolve()?.IsSubtypeOf(td) ?? false); } /// /// Try to resolve and load the given assembly DLL. /// /// Name of the assembly, of the type . /// Directory to search the assembly from. /// The loaded assembly. /// True, if the assembly was found and loaded. Otherwise, false. public static bool TryResolveDllAssembly(AssemblyName assemblyName, string directory, out Assembly assembly) => TryResolveDllAssembly(assemblyName, directory, Assembly.LoadFrom, out assembly); /// /// Try to resolve and load the given assembly DLL. /// /// Name of the assembly, of the type . /// Directory to search the assembly from. /// Reader parameters that contain possible custom assembly resolver. /// The loaded assembly. /// True, if the assembly was found and loaded. Otherwise, false. public static bool TryResolveDllAssembly(AssemblyName assemblyName, string directory, ReaderParameters readerParameters, out AssemblyDefinition assembly) => TryResolveDllAssembly(assemblyName, directory, s => AssemblyDefinition.ReadAssembly(s, readerParameters), out assembly); /// /// Tries to create a file with the given name /// /// Path of the file to create /// File open mode /// Resulting filestream /// File access options /// File share options /// public static bool TryOpenFileStream(string path, FileMode mode, out FileStream fileStream, FileAccess access = FileAccess.ReadWrite, FileShare share = FileShare.Read) { try { fileStream = new FileStream(path, mode, access, share); return true; } catch (IOException) { fileStream = null; return false; } } public static IEnumerable EnumerateAllMethods(this TypeDefinition type) { var currentType = type; while (currentType != null) { foreach (var method in currentType.Methods) yield return method; currentType = currentType.BaseType?.Resolve(); } } /// /// Compute a MD5 hash of the given stream. /// /// Stream to hash /// MD5 hash as a hex string public static string HashStream(Stream stream) { using var md5 = MD5.Create(); var buf = new byte[4096]; int read; while ((read = stream.Read(buf, 0, buf.Length)) > 0) md5.TransformBlock(buf, 0, read, buf, 0); md5.TransformFinalBlock(new byte[0], 0, 0); return ByteArrayToString(md5.Hash); } /// /// Hash a list of strings using MD5 /// /// Strings to hash /// MD5 of the strings public static string HashStrings(params string[] strings) { using var md5 = MD5.Create(); foreach (var str in strings) { var bytes = Encoding.UTF8.GetBytes(str); md5.TransformBlock(bytes, 0, bytes.Length, null, 0); } md5.TransformFinalBlock(new byte[0], 0, 0); return ByteArrayToString(md5.Hash); } /// /// Convert the given array to a hex string. /// /// Bytes to convert. /// Bytes reinterpreted as a hex number. public static string ByteArrayToString(byte[] data) { var builder = new StringBuilder(data.Length * 2); foreach (var b in data) builder.AppendFormat("{0:x2}", b); return builder.ToString(); } /// /// Get a value of a command line argument /// /// Argument name /// Next argument after the given argument name. If not found, returns null. public static string GetCommandLineArgValue(string arg) { var args = Environment.GetCommandLineArgs(); for (var i = 1; i < args.Length; i++) if (args[i] == arg && i + 1 < args.Length) return args[i + 1]; return null; } /// /// Try to parse given string as an assembly name /// /// Fully qualified assembly name /// Resulting instance /// true, if parsing was successful, otherwise false /// /// On some versions of mono, using fails because it runs on unmanaged side /// which has problems with encoding. /// Using solves this by doing parsing on managed side instead. /// public static bool TryParseAssemblyName(string fullName, out AssemblyName assemblyName) { try { assemblyName = new AssemblyName(fullName); return true; } catch (Exception) { assemblyName = null; return false; } } internal static void AddCecilPlatformAssemblies(this AppDomain appDomain, string assemblyDir) { if (!Directory.Exists(assemblyDir)) return; // Cecil 0.11 requires one to manually set up list of trusted assemblies for assembly resolving var curTrusted = appDomain.GetData(TRUSTED_PLATFORM_ASSEMBLIES) as string; var addTrusted = string.Join(Path.PathSeparator.ToString(), Directory.GetFiles(assemblyDir, "*.dll", SearchOption.TopDirectoryOnly)); var newTrusted = curTrusted == null ? addTrusted : $"{curTrusted}{Path.PathSeparator}{addTrusted}"; appDomain.SetData(TRUSTED_PLATFORM_ASSEMBLIES, newTrusted); } /// /// Gets unique files in all given directories. If the file with the same name exists in multiple directories, /// only the first occurrence is returned. /// /// Directories to search from. /// File pattern to search. /// Collection of all files in the directories. public static IEnumerable GetUniqueFilesInDirectories(IEnumerable directories, string pattern = "*") { var result = new Dictionary(StringComparer.InvariantCultureIgnoreCase); foreach (var directory in directories) { // A configured search directory (e.g. a missing unstripped_corlib) may not exist; warn and skip it // instead of letting Directory.GetFiles throw DirectoryNotFoundException. if (!Directory.Exists(directory)) { Logger.Log(LogLevel.Warning, $"Skipping search directory that does not exist: {directory}"); continue; } foreach (var file in Directory.GetFiles(directory, pattern)) { var fileName = Path.GetFileName(file); if (!result.ContainsKey(fileName)) result[fileName] = file; } } return result.Values; } }