private void TestNativeDetoursUnix(dt_rand d_not_rand, IntPtr ptr_not_rand)
{
DidNothing = true;
libc_rand();
Assert.True(DidNothing);
DidNothing = true;
Assert.Equal(-1, d_not_rand());
Assert.False(DidNothing);
using (new NativeDetour(
typeof(NativeDetourTest).GetMethod("libc_rand"),
typeof(NativeDetourTest).GetMethod("not_rand")
)) {
DidNothing = true;
Assert.Equal(-1, libc_rand());
Assert.False(DidNothing);
}
DidNothing = true;
libc_rand();
Assert.True(DidNothing);
/* dl's dlopen doesn't follow ld, meaning that we need to...
* - use libc.so.6 on Linux and hope that everyone is using glibc.
* - use /usr/lib/libc.dylib on macOS because macOS is macOS.
* If libc cannot be dlopened, skip the native -> managed detour test.
* - ade
*/
if (!(PlatformHelper.Is(Platform.Linux) && DynDll.TryOpenLibrary("libc.so.6", out IntPtr libc)) &&
!(PlatformHelper.Is(Platform.MacOS) && DynDll.TryOpenLibrary("/usr/lib/libc.dylib", out libc)) &&
!DynDll.TryOpenLibrary($"libc.{PlatformHelper.LibrarySuffix}", out libc))
{
return;
}
NativeDetour d = new NativeDetour(
libc.GetFunction("rand"),
ptr_not_rand
);
DidNothing = true;
Assert.Equal(-1, libc_rand());
Assert.False(DidNothing);
d.Dispose();
DidNothing = true;
libc_rand();
Assert.True(DidNothing);
}
private void TestNativeDetoursWindows(dt_rand d_not_rand, IntPtr ptr_not_rand)
{
if (!DynDll.TryOpenLibrary($"msvcrt.{PlatformHelper.LibrarySuffix}", out IntPtr msvcrt))
{
Console.WriteLine("NativeDetourTest skipped - msvcrt not found!");
return;
}
if (!msvcrt.TryGetFunction("rand", out IntPtr ptr_msvcrt_rand))
{
Console.WriteLine("NativeDetourTest skipped - rand not found in msvcrt!");
return;
}
DidNothing = true;
msvcrt_rand();
Assert.True(DidNothing);
DidNothing = true;
Assert.Equal(-1, d_not_rand());
Assert.False(DidNothing);
using (new NativeDetour(
typeof(NativeDetourTest).GetMethod("msvcrt_rand"),
typeof(NativeDetourTest).GetMethod("not_rand")
)) {
DidNothing = true;
Assert.Equal(-1, msvcrt_rand());
Assert.False(DidNothing);
}
DidNothing = true;
msvcrt_rand();
Assert.True(DidNothing);
NativeDetour d = new NativeDetour(
ptr_msvcrt_rand,
ptr_not_rand
);
DidNothing = true;
Assert.Equal(-1, msvcrt_rand());
Assert.False(DidNothing);
d.Dispose();
DidNothing = true;
msvcrt_rand();
Assert.True(DidNothing);
}
static LibSystem()
{
typeof(LibSystem).ResolveDynDllImports(new Dictionary <string, List <DynDllMapping> >
{
["libSystem"] = new List <DynDllMapping>
{
"/usr/lib/libSystem.dylib" // OSX POSIX
}
});
var libsystem = DynDll.OpenLibrary("/usr/lib/libSystem.dylib");
TaskSelf = libsystem.GetFunction("mach_task_self_"); // This isn't a function but rather an exported symbol
}
public DetourNativeMonoPlatform(IDetourNativePlatform inner, string libmono)
{
Inner = inner;
Dictionary <string, List <DynDllMapping> > mappings = new Dictionary <string, List <DynDllMapping> >();
if (!string.IsNullOrEmpty(libmono))
{
mappings.Add("mono", new List <DynDllMapping>()
{
libmono
});
}
DynDll.ResolveDynDllImports(this, mappings);
_Pagesize = mono_pagesize();
}
public DetourNativeMonoPlatform(IDetourNativePlatform inner, string libmono)
{
Inner = inner;
#if MONOMOD_RUNTIMEDETOUR
Dictionary <string, DynDllMapping> mappings = new Dictionary <string, DynDllMapping>();
if (!string.IsNullOrEmpty(libmono))
{
mappings.Add("mono", new DynDllMapping {
ResolveAs = libmono
});
}
DynDll.ResolveDynDllImports(this, mappings);
#endif
_Pagesize = mono_pagesize();
}
protected static IntPtr GetJitObject()
{
if (getJit == null)
{
// To make sure we get the right clrjit, we enumerate the process's modules and find the one
// with the name we care about, then use its full path to gat a handle and load symbols.
Process currentProc = Process.GetCurrentProcess();
ProcessModule clrjitModule = currentProc.Modules.Cast <ProcessModule>()
.FirstOrDefault(m => Path.GetFileNameWithoutExtension(m.FileName).EndsWith("clrjit"));
if (clrjitModule == null)
{
throw new PlatformNotSupportedException();
}
if (!DynDll.TryOpenLibrary(clrjitModule.FileName, out IntPtr clrjitPtr))
{
throw new PlatformNotSupportedException();
}
if (PlatformHelper.Is(Platform.Windows))
{
// we can use this check only on Windows, because only Windows actually has FilveVersionInfo
// this is preferred because it checks the version of the JIT, rather than the runtime library
// which is what actually determines the layout.
isNet5Jit = clrjitModule.FileVersionInfo.ProductMajorPart >= 5;
}
else
{
// this gets System.Private.CorLib's major version, which *should* match the runtime version
// it is the only method we have at the moment to detect it on non-Windows platforms
isNet5Jit = typeof(object).Assembly.GetName().Version.Major >= 5;
}
try {
getJit = clrjitPtr.GetFunction(nameof(getJit)).AsDelegate <d_getJit>();
} catch {
DynDll.CloseLibrary(clrjitPtr);
throw;
}
}
return(getJit());
}
private void TestNativeDetoursWindows(dt_rand d_not_rand, IntPtr ptr_not_rand)
{
DidNothing = true;
msvcrt_rand();
Assert.True(DidNothing);
DidNothing = true;
Assert.Equal(-1, d_not_rand());
Assert.False(DidNothing);
using (new NativeDetour(
typeof(NativeDetourTest).GetMethod("msvcrt_rand"),
typeof(NativeDetourTest).GetMethod("not_rand")
)) {
DidNothing = true;
Assert.Equal(-1, msvcrt_rand());
Assert.False(DidNothing);
}
DidNothing = true;
msvcrt_rand();
Assert.True(DidNothing);
NativeDetour d = new NativeDetour(
DynDll.OpenLibrary($"msvcrt.{PlatformHelper.LibrarySuffix}").GetFunction("rand"),
ptr_not_rand
);
DidNothing = true;
Assert.Equal(-1, msvcrt_rand());
Assert.False(DidNothing);
d.Dispose();
DidNothing = true;
msvcrt_rand();
Assert.True(DidNothing);
}
static DpiUtils()
{
if (DynDll.TryOpenLibrary("user32.dll", out IntPtr p_user32))
{
if (p_user32.TryGetFunction("SetProcessDpiAwarenessContext", out IntPtr p_SetProcessDpiAwarenessContext))
{
SetProcessDpiAwarenessContext = p_SetProcessDpiAwarenessContext.AsDelegate <d_SetProcessDpiAwarenessContext>();
}
if (p_user32.TryGetFunction("SetProcessDPIAware", out IntPtr p_SetProcessDPIAware))
{
SetProcessDPIAware = p_SetProcessDPIAware.AsDelegate <d_SetProcessDPIAware>();
}
}
if (DynDll.TryOpenLibrary("SHCore.dll", out IntPtr p_SHCore))
{
if (p_SHCore.TryGetFunction("SetProcessDpiAwareness", out IntPtr p_SetProcessDpiAwareness))
{
SetProcessDpiAwareness = p_SetProcessDpiAwareness.AsDelegate <d_SetProcessDpiAwareness>();
}
}
}
static void Main(string[] args)
{
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
Args = args;
if (!Directory.Exists(InstallDir))
{
Directory.CreateDirectory(InstallDir);
}
if (!Directory.Exists(ConfigDir))
{
Directory.CreateDirectory(ConfigDir);
}
Environment.SetEnvironmentVariable("LOCAL_LUA_DEBUGGER_VSCODE", "0");
Environment.CurrentDirectory = InstallDir;
if (File.Exists(LogPath))
{
File.Delete(LogPath);
}
using (Stream fileStream = new FileStream(LogPath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite | FileShare.Delete))
using (StreamWriter fileWriter = new StreamWriter(fileStream, Console.OutputEncoding))
using (LogWriter logWriter = new LogWriter {
STDOUT = Console.Out,
File = fileWriter
}) {
try {
Console.SetOut(logWriter);
AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionHandler;
Console.WriteLine($"Olympus Launcher {typeof(Program).Assembly.GetName().Version}");
if (StartMain())
{
Console.WriteLine("Quitting early");
return;
}
Console.WriteLine("Starting up form");
// Application.SetHighDpiMode(HighDpiMode.SystemAware);
DynDll.ResolveDynDllImports(typeof(DpiUtils));
if (DpiUtils.SetProcessDpiAwarenessContext != null)
{
DpiUtils.SetProcessDpiAwarenessContext(DpiUtils.DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
}
else if (DpiUtils.SetProcessDpiAwareness != null)
{
DpiUtils.SetProcessDpiAwareness(DpiUtils.PROCESS_DPI_AWARENESS.Process_Per_Monitor_DPI_Aware);
}
else if (DpiUtils.SetProcessDPIAware != null)
{
DpiUtils.SetProcessDPIAware();
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
Application.Run(new OlympusForm());
} finally {
if (logWriter.STDOUT != null)
{
Console.SetOut(logWriter.STDOUT);
logWriter.STDOUT = null;
}
}
}
}