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;
}
}