public async Task <int> ExecuteCommand(CommandSettings command)
{
try
{
VssUtil.InitializeVssClientSettings(HostContext.UserAgents, HostContext.WebProxy);
_inConfigStage = true;
_completedCommand.Reset();
_term.CancelKeyPress += CtrlCHandler;
//register a SIGTERM handler
HostContext.Unloading += Runner_Unloading;
// TODO Unit test to cover this logic
Trace.Info(nameof(ExecuteCommand));
var configManager = HostContext.GetService <IConfigurationManager>();
// command is not required, if no command it just starts if configured
// TODO: Invalid config prints usage
if (command.Help)
{
PrintUsage(command);
return(Constants.Runner.ReturnCode.Success);
}
if (command.Version)
{
_term.WriteLine(BuildConstants.RunnerPackage.Version);
return(Constants.Runner.ReturnCode.Success);
}
if (command.Commit)
{
_term.WriteLine(BuildConstants.Source.CommitHash);
return(Constants.Runner.ReturnCode.Success);
}
if (command.Check)
{
var url = command.GetUrl();
var pat = command.GetGitHubPersonalAccessToken(required: true);
var checkExtensions = HostContext.GetService <IExtensionManager>().GetExtensions <ICheckExtension>();
var sortedChecks = checkExtensions.OrderBy(x => x.Order);
foreach (var check in sortedChecks)
{
_term.WriteLine($"**********************************************************************************************************************");
_term.WriteLine($"** Check: {check.CheckName}");
_term.WriteLine($"** Description: {check.CheckDescription}");
_term.WriteLine($"**********************************************************************************************************************");
var result = await check.RunCheck(url, pat);
if (!result)
{
_term.WriteLine($"** **");
_term.WriteLine($"** F A I L **");
_term.WriteLine($"** **");
_term.WriteLine($"**********************************************************************************************************************");
_term.WriteLine($"** Log: {check.CheckLog}");
_term.WriteLine($"** Help Doc: {check.HelpLink}");
_term.WriteLine($"**********************************************************************************************************************");
}
else
{
_term.WriteLine($"** **");
_term.WriteLine($"** P A S S **");
_term.WriteLine($"** **");
_term.WriteLine($"**********************************************************************************************************************");
_term.WriteLine($"** Log: {check.CheckLog}");
_term.WriteLine($"**********************************************************************************************************************");
}
_term.WriteLine();
_term.WriteLine();
}
return(Constants.Runner.ReturnCode.Success);
}
// Configure runner prompt for args if not supplied
// Unattended configure mode will not prompt for args if not supplied and error on any missing or invalid value.
if (command.Configure)
{
try
{
await configManager.ConfigureAsync(command);
return(Constants.Runner.ReturnCode.Success);
}
catch (Exception ex)
{
Trace.Error(ex);
_term.WriteError(ex.Message);
return(Constants.Runner.ReturnCode.TerminatedError);
}
}
// remove config files, remove service, and exit
if (command.Remove)
{
try
{
await configManager.UnconfigureAsync(command);
return(Constants.Runner.ReturnCode.Success);
}
catch (Exception ex)
{
Trace.Error(ex);
_term.WriteError(ex.Message);
return(Constants.Runner.ReturnCode.TerminatedError);
}
}
_inConfigStage = false;
// warmup runner process (JIT/CLR)
// In scenarios where the runner is single use (used and then thrown away), the system provisioning the runner can call `Runner.Listener --warmup` before the machine is made available to the pool for use.
// this will optimizes the runner process startup time.
if (command.Warmup)
{
var binDir = HostContext.GetDirectory(WellKnownDirectory.Bin);
foreach (var assemblyFile in Directory.EnumerateFiles(binDir, "*.dll"))
{
try
{
Trace.Info($"Load assembly: {assemblyFile}.");
var assembly = Assembly.LoadFrom(assemblyFile);
var types = assembly.GetTypes();
foreach (Type loadedType in types)
{
try
{
Trace.Info($"Load methods: {loadedType.FullName}.");
var methods = loadedType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);
foreach (var method in methods)
{
if (!method.IsAbstract && !method.ContainsGenericParameters)
{
Trace.Verbose($"Prepare method: {method.Name}.");
RuntimeHelpers.PrepareMethod(method.MethodHandle);
}
}
}
catch (Exception ex)
{
Trace.Error(ex);
}
}
}
catch (Exception ex)
{
Trace.Error(ex);
}
}
return(Constants.Runner.ReturnCode.Success);
}
RunnerSettings settings = configManager.LoadSettings();
var store = HostContext.GetService <IConfigurationStore>();
bool configuredAsService = store.IsServiceConfigured();
// Run runner
if (command.Run) // this line is current break machine provisioner.
{
// Error if runner not configured.
if (!configManager.IsConfigured())
{
_term.WriteError("Runner is not configured.");
PrintUsage(command);
return(Constants.Runner.ReturnCode.TerminatedError);
}
Trace.Verbose($"Configured as service: '{configuredAsService}'");
//Get the startup type of the runner i.e., autostartup, service, manual
StartupType startType;
var startupTypeAsString = command.GetStartupType();
if (string.IsNullOrEmpty(startupTypeAsString) && configuredAsService)
{
// We need try our best to make the startup type accurate
// The problem is coming from runner autoupgrade, which result an old version service host binary but a newer version runner binary
// At that time the servicehost won't pass --startuptype to Runner.Listener while the runner is actually running as service.
// We will guess the startup type only when the runner is configured as service and the guess will based on whether STDOUT/STDERR/STDIN been redirect or not
Trace.Info($"Try determine runner startup type base on console redirects.");
startType = (Console.IsErrorRedirected && Console.IsInputRedirected && Console.IsOutputRedirected) ? StartupType.Service : StartupType.Manual;
}
else
{
if (!Enum.TryParse(startupTypeAsString, true, out startType))
{
Trace.Info($"Could not parse the argument value '{startupTypeAsString}' for StartupType. Defaulting to {StartupType.Manual}");
startType = StartupType.Manual;
}
}
Trace.Info($"Set runner startup type - {startType}");
HostContext.StartupType = startType;
if (command.RunOnce)
{
_term.WriteLine("Warning: '--once' is going to be deprecated in the future, please consider using '--ephemeral' during runner registration.", ConsoleColor.Yellow);
_term.WriteLine("https://docs.github.com/en/actions/hosting-your-own-runners/autoscaling-with-self-hosted-runners#using-ephemeral-runners-for-autoscaling", ConsoleColor.Yellow);
}
// Run the runner interactively or as service
return(await RunAsync(settings, command.RunOnce || settings.Ephemeral));
}
else
{
PrintUsage(command);
return(Constants.Runner.ReturnCode.Success);
}
}
finally
{
_term.CancelKeyPress -= CtrlCHandler;
HostContext.Unloading -= Runner_Unloading;
_completedCommand.Set();
}
}
//patch the compiled JIT assembly with a primitive JMP hook
private unsafe byte[] PatchJMP(MethodInfo original, MethodInfo replacement)
{
//JIT compile methods
RuntimeHelpers.PrepareMethod(original.MethodHandle);
RuntimeHelpers.PrepareMethod(replacement.MethodHandle);
//compile both functions and get pointers to them.
IntPtr originalSite = original.MethodHandle.GetFunctionPointer();
IntPtr replacementSite = replacement.MethodHandle.GetFunctionPointer();
//instruction opcodes are 13 bytes on 64-bit, 7 bytes on 32-bit
uint offset = (is64 ? 13u : 6u);
//we store the original opcodes for restoration later
byte[] originalOpcodes = new byte[offset];
unsafe
{
//segfault protection
uint oldProtecton = VirtualProtect(originalSite, (uint)originalOpcodes.Length, (uint)Natives.PageProtection.PAGE_EXECUTE_READWRITE);
//get unmanaged function pointer to address of original site
byte *originalSitePointer = (byte *)originalSite.ToPointer();
//copy the original opcodes
for (int k = 0; k < offset; k++)
{
originalOpcodes[k] = *(originalSitePointer + k);
}
//check which architecture we are patching for
if (is64)
{
//mov r11, replacementSite
*originalSitePointer = 0x49;
*(originalSitePointer + 1) = 0xBB;
*((ulong *)(originalSitePointer + 2)) = (ulong)replacementSite.ToInt64(); //sets 8 bytes
//jmp r11
*(originalSitePointer + 10) = 0x41;
*(originalSitePointer + 11) = 0xFF;
*(originalSitePointer + 12) = 0xE3;
}
else
{
//push replacementSite
*originalSitePointer = 0x68;
*((uint *)(originalSitePointer + 1)) = (uint)replacementSite.ToInt32(); //sets 4 bytes
//ret
*(originalSitePointer + 5) = 0xC3;
}
//flush insutruction cache to make sure our new code executes
FlushInstructionCache(originalSite, (uint)originalOpcodes.Length);
//done
VirtualProtect(originalSite, (uint)originalOpcodes.Length, oldProtecton);
}
//return original opcodes
return(originalOpcodes);
}
public void Setup()
{
RuntimeHelpers.PrepareMethod(typeof(Plain).GetMethod("Print").MethodHandle);
}
OnAssemblyLoad(
object Sender,
AssemblyLoadEventArgs Args
)
{
//
// STEP1: Wait for System.Management.Automation (SMA)
//
string assemblyName = Args.LoadedAssembly.GetName().Name;
Console.WriteLine("[*] Loading assembly " + assemblyName);
if (assemblyName != "System.Management.Automation")
{
return;
}
AppDomain.CurrentDomain.AssemblyLoad -= s_EventHandler;
Assembly smaAssembly = Args.LoadedAssembly;
//
// You may want to break into a debugger for debugging.
//
//Debugger.Launch();
//
// STEP2: Determine a version of SMA
//
// Need a version of SMA since the ScanContent method exists only
// in PowerShell v5 or later. PowerShell version can be obtained
// via the PSVersion property of the PSVersionInfo class.
//
Type psVersionInfo = smaAssembly.GetType(
"System.Management.Automation.PSVersionInfo");
PropertyInfo psVersion = psVersionInfo.GetProperty(
"PSVersion",
BindingFlags.Static | BindingFlags.NonPublic,
null,
typeof(Version),
Type.EmptyTypes,
null);
var version = (Version)psVersion.GetValue(null, null);
if (version.Major != 5)
{
Console.WriteLine("[-] Unsupported PowerShell version detected.");
return;
}
//
// STEP3: Find methods via reflection
//
// We need tree methods per target method:
// target - A method to be hooked. It normally exists out side of
// our code.
// handler - A detour method to be called instead of the target
// method after a hook is installed.
// trampoline - A method used to call an original of the target
// method after a hook is installed.
//
const BindingFlags anyType = BindingFlags.Static |
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.NonPublic;
//
// Indicates what parameters the methods take. Reflection requires
// this information on the top of a method name since a method can
// be overloaded for a different set of parameters.
//
// In our case, the methods are defined as follows:
// static AMSI_RESULT ScanContent(string Content,
// string SourceMetadata);
// static AMSI_RESULT ScanContentHookHandler(string Content,
// string SourceMetadata);
// static AMSI_RESULT ScanContentTrampoline(string Content,
// string SourceMetadata);
//
var targetMethodType = new Type[] { typeof(string), typeof(string), };
var handlerMethodType = new Type[] { typeof(string), typeof(string), };
var trampolineMethodType = new Type[] { typeof(string), typeof(string), };
Type targetMethodClass = smaAssembly.GetType(
"System.Management.Automation.AmsiUtils");
Type handlerMethodClass = typeof(HookScanContent);
Type trampolineMethodClass = typeof(HookScanContent);
MethodInfo target = targetMethodClass.GetMethod(
"ScanContent",
anyType,
null,
targetMethodType,
null);
MethodInfo hookHandler = handlerMethodClass.GetMethod(
"ScanContentHookHandler",
anyType,
null,
handlerMethodType,
null);
MethodInfo trampoline = trampolineMethodClass.GetMethod(
"ScanContentTrampoline",
anyType,
null,
trampolineMethodType,
null);
//
// STEP4: Get addresses of native code of the methods
//
RuntimeHelpers.PrepareMethod(target.MethodHandle);
RuntimeHelpers.PrepareMethod(hookHandler.MethodHandle);
RuntimeHelpers.PrepareMethod(trampoline.MethodHandle);
IntPtr targetAddr = target.MethodHandle.GetFunctionPointer();
IntPtr hookHandlerAddr = hookHandler.MethodHandle.GetFunctionPointer();
IntPtr trampolineAddr = trampoline.MethodHandle.GetFunctionPointer();
//
// STEP5: Install a hook on to the target method
//
// Overwrite native code of the ScanContent method. This is standard
// inline hooking, only differences are that we initiate hooking
// from C# (typically C/C++) and a target is compiled .NET native
// code.
//
// This example code uses MinHook (https://github.com/TsudaKageyu/minhook)
// for installing hooks since the author did not find any suitable
// inline hooking library for C#.
//
if (!MinHook.InstallHook(targetAddr, hookHandlerAddr, trampolineAddr))
{
return;
}
//
// STEP6: PROFIT!
//
Console.WriteLine("[*] The ScanContent method has been hooked.");
}
MethodJitter(string module, MemberFilter typeFilter, MemberFilter methodFilter, bool runClassConstructors, IEnumerable <string> searchPaths)
{
this.typeFilter = typeFilter;
this.methodFilter = methodFilter;
var paths = new List <string>();
paths.Add(Path.GetDirectoryName(Path.GetFullPath(module)));
foreach (var path in searchPaths)
{
if (Directory.Exists(path))
{
paths.Add(path);
}
}
this.searchPaths = paths.ToArray();
nameToAssembly = new Dictionary <string, Assembly>();
#if NETCOREAPP
System.Runtime.Loader.AssemblyLoadContext.Default.Resolving += AssemblyLoadContext_Resolving;
#elif NETFRAMEWORK
AppDomain.CurrentDomain.AssemblyResolve += AppDomain_AssemblyResolve;
#else
#error Unknown target framework
#endif
var asm = Assembly.LoadFile(module);
var allTypes = GetTypes(asm).ToArray();
if (runClassConstructors)
{
foreach (var type in allTypes)
{
if ((object)type.TypeInitializer != null)
{
try {
RuntimeHelpers.RunClassConstructor(type.TypeHandle);
}
catch (Exception ex) {
Console.WriteLine($"Failed to run {type.FullName} cctor: {ex.Message}");
}
}
}
}
foreach (var type in allTypes)
{
if (!typeFilter.IsMatch(MakeClrmdTypeName(type.FullName), (uint)type.MetadataToken))
{
continue;
}
bool isDelegate = typeof(Delegate).IsAssignableFrom(type);
foreach (var method in GetMethods(type))
{
if (method.IsAbstract)
{
continue;
}
if (method.IsGenericMethod)
{
continue;
}
if (!methodFilter.IsMatch(method.Name, (uint)method.MetadataToken))
{
continue;
}
#if NETCOREAPP
// Not supported on .NET Core
if (isDelegate && method is MethodInfo m && m.IsVirtual && (m.Name == "BeginInvoke" || m.Name == "EndInvoke"))
{
continue;
}
#endif
try {
RuntimeHelpers.PrepareMethod(method.MethodHandle);
}
catch (Exception ex) {
string methodName;
try {
methodName = method.ToString();
}
catch {
methodName = $"{method.Name} ({method.MetadataToken:X8})";
}
Console.WriteLine($"{type.FullName}: {methodName}: Failed to jit: {ex.Message}");
}
}
}
}
public void ctor(ProcessManager manager)
{
//Delegate to call the base constructor
Type[] constructorSignature = new Type[2];
constructorSignature[0] = typeof(ProcessManager);
constructorSignature[1] = typeof(ProcessManager.ProcessID);
RuntimeMethodHandle handle = typeof(Menu.Menu).GetConstructor(constructorSignature).MethodHandle;
RuntimeHelpers.PrepareMethod(handle);
IntPtr ptr = handle.GetFunctionPointer();
Action <ProcessManager, ProcessManager.ProcessID> funct = (Action <ProcessManager, ProcessManager.ProcessID>)Activator.CreateInstance(typeof(Action <ProcessManager, ProcessManager.ProcessID>), this, ptr);
funct(manager, ProcessManager.ProcessID.SlugcatSelect);//Menu.Menu Constructor
pages.Add(new Menu.Page(this, null, "main", 0));
if (!manager.rainWorld.flatIllustrations)
{
rainEffect = new Menu.RainEffect(this, pages[0]);
pages[0].subObjects.Add(rainEffect);
}
if (CheckUnlockRed())
{
manager.rainWorld.progression.miscProgressionData.redUnlocked = true;
}
slugcatColorOrder = new int[]
{
1,
0,
2
};
for (int i = 0; i < slugcatColorOrder.Length; i++)
{
if (slugcatColorOrder[i] == manager.rainWorld.progression.miscProgressionData.currentlySelectedSinglePlayerSlugcat)
{
slugcatPageIndex = i;
}
}
slugcatPageIndex = 1;
saveGameData = new Menu.SlugcatSelectMenu.SaveGameData[3];
for (int j = 0; j < 3; j++)
{
saveGameData[j] = MineForSaveData(manager, slugcatColorOrder[j]);
}
if (saveGameData[2] != null && ((saveGameData[2].redsDeath && saveGameData[2].cycle >= RedsIllness.RedsCycles(saveGameData[2].redsExtraCycles)) || saveGameData[2].ascended))
{
redIsDead = true;
}
int num = 0;
for (int k = 0; k < 3; k++)
{
if (saveGameData[k] != null)
{
num++;
}
}
if (num == 1)
{
for (int l = 0; l < 3; l++)
{
if (saveGameData[l] != null)
{
slugcatPageIndex = l;
break;
}
}
}
slugcatPages = new Menu.SlugcatSelectMenu.SlugcatPage[3];
for (int m = 0; m < slugcatPages.Length; m++)
{
if (saveGameData[m] != null)
{
slugcatPages[m] = new Menu.SlugcatSelectMenu.SlugcatPageContinue(this, null, 1 + m, slugcatColorOrder[m]);
}
else
{
slugcatPages[m] = new Menu.SlugcatSelectMenu.SlugcatPageNewGame(this, null, 1 + m, slugcatColorOrder[m]);
}
pages.Add(slugcatPages[m]);
}
startButton = new Menu.HoldButton(this, pages[0], string.Empty, "START", new Vector2(683f, 85f), 40f);
pages[0].subObjects.Add(startButton);
pages[0].subObjects.Add(new Menu.SimpleButton(this, pages[0], "BACK", "BACK", new Vector2(200f, 668f), new Vector2(110f, 30f)));
//this.pages[0].subObjects.Add(new Menu.BigArrowButton(this, this.pages[0], "PREV", new Vector2(200f, 50f), -1));
//this.pages[0].subObjects.Add(new Menu.BigArrowButton(this, this.pages[0], "NEXT", new Vector2(1116f, 50f), 1));
//Removed access to other characters
float textWidth = 85f;
restartCheckbox = new Menu.CheckBox(this, pages[0], this, new Vector2(startButton.pos.x + 200f, 30f), textWidth, "Restart game", "RESTART");
pages[0].subObjects.Add(restartCheckbox);
UpdateStartButtonText();
UpdateSelectedSlugcatInMiscProg();
mySoundLoopID = SoundID.MENU_Main_Menu_LOOP;
}
// Token: 0x06000021 RID: 33 RVA: 0x00003404 File Offset: 0x00001604
private static IntPtr GetAddress(MethodBase methodBase)
{
RuntimeHelpers.PrepareMethod(methodBase.MethodHandle);
return(methodBase.MethodHandle.GetFunctionPointer());
}
private static IntPtr GetRawAddress(string name)
{
var methodHandle = typeof(Sample).GetMethod(name, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).MethodHandle;
RuntimeHelpers.PrepareMethod(methodHandle);
return methodHandle.GetFunctionPointer();
}
public void Setup()
{
RuntimeHelpers.PrepareMethod(typeof(RangeEnumerableWithClassEnumerator.Enumerator).GetMethod("MoveNext", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).MethodHandle);
}
public static void hijack(MethodInfo target, MethodInfo replaceWith)
{
//*
bool withThis = !target.IsStatic && replaceWith.IsStatic; // target.CallingConvention.HasFlag(CallingConventions.HasThis);
if (target.ReturnType != replaceWith.ReturnType)
{
throw new ArgumentException("Target and replacement methods must match; return type");
}
if (target.GetParameters().Length != replaceWith.GetParameters().Length - (withThis ? 1 : 0))
{
throw new ArgumentException("Target and replacement methods must match; parameter count");
}
if (withThis && target.DeclaringType != replaceWith.GetParameters()[0].ParameterType)
{
throw new ArgumentException("Target and replacement methods must match; parameter 0 (this)");
}
for (int i = 0; i < target.GetParameters().Length; ++i)
{
var tparam = target.GetParameters()[i];
var rparam = replaceWith.GetParameters()[i + (withThis ? 1 : 0)];
if (tparam.ParameterType != rparam.ParameterType)
{
throw new ArgumentException("Target and replacement methods must match; parameter " + (i + +(withThis ? 1 : 0)));
}
}
//*/
Log.debug("Hijacking method \"" + target.DeclaringType + ": " + target + "\", replacing with \"" + replaceWith.DeclaringType + ": " + replaceWith + "\".");
try
{
RuntimeHelpers.PrepareMethod(target.MethodHandle);
}
catch (Exception e)
{
Log.warn("WARNING (1): " + e);
}
try
{
RuntimeHelpers.PrepareMethod(replaceWith.MethodHandle);
}
catch (Exception e)
{
Log.warn("WARNING (2): " + e);
}
if (target.IsVirtual)
{
// http://stackoverflow.com/a/38783635
unsafe
{
UInt64 *methodDesc = (UInt64 *)(replaceWith.MethodHandle.Value.ToPointer());
int index = (int)(((*methodDesc) >> 32) & 0xFF);
if (IntPtr.Size == 4)
{
uint *classStart = (uint *)replaceWith.DeclaringType.TypeHandle.Value.ToPointer();
classStart += 10;
classStart = (uint *)*classStart;
uint *tar = classStart + index;
uint *inj = (uint *)target.MethodHandle.Value.ToPointer() + 2;
//int* tar = (int*)methodToReplace.MethodHandle.Value.ToPointer() + 2;
*tar = *inj;
}
else
{
ulong *classStart = (ulong *)replaceWith.DeclaringType.TypeHandle.Value.ToPointer();
classStart += 8;
classStart = (ulong *)*classStart;
ulong *tar = classStart + index;
ulong *inj = (ulong *)target.MethodHandle.Value.ToPointer() + 1;
//ulong* tar = (ulong*)methodToReplace.MethodHandle.Value.ToPointer() + 1;
*tar = *inj;
}
}
}
else
{
// http://stackoverflow.com/a/36415711
unsafe
{
int insOffset = 1;
if (IntPtr.Size == 4)
{
insOffset = 2;
}
Log.trace("Offset: " + insOffset);
int *ttar = (int *)target.MethodHandle.Value.ToPointer() + insOffset;
int *rtar = (int *)replaceWith.MethodHandle.Value.ToPointer() + insOffset;
// Debugger.IsAttached section not needed with VS2017? Or whatever caused the change
if (false && Debugger.IsAttached)
{
Log.trace("Debugger is attached.");
byte *tinsn = (byte *)(*ttar);
byte *rinsn = (byte *)(*rtar);
int *tsrc = (int *)(tinsn + 1);
int *rsrc = (int *)(rinsn + 1);
Log.trace("Data (1): " + new IntPtr(ttar) + "=" + (ttar == null ? 0 : (*ttar)) + " " + new IntPtr(rtar) + "=" + (rtar == null ? 0 : (*rtar)));
Log.trace("Data (2): " + new IntPtr(tinsn) + "=" + (tinsn == null ? 0 : (*tinsn)) + " " + new IntPtr(rinsn) + "=" + (rinsn == null ? 0 : (*rinsn)));
Log.trace("Data (3): " + new IntPtr(tsrc) + "=" + (tinsn == null ? 1 : (*tsrc)) + " " + new IntPtr(rsrc) + "=" + (rinsn == null ? 1 : (*rsrc)));
(*tsrc) = (((int)rinsn + 5) + (*rsrc)) - ((int)tinsn + 5);
}
else
{
Log.trace("Debugger is not attached.");
Log.trace("Data: " + new IntPtr(ttar) + "=" + (*ttar) + " " + new IntPtr(rtar) + "=" + (*rtar));
(*ttar) = (*rtar);
}
}
}
Log.trace("Done");
}
public static void PreJitAssembly(Assembly a)
{
// Storage to ensure not loading the same assembly twice and optimize calls to GetAssemblies()
var loaded = new HashSet <string>();
PrepareAssembly(a);
LoadReferencedAssemblies(a);
// Filter to avoid loading all the .net framework
bool ShouldLoad(string assemblyName)
{
return(!loaded.Contains(assemblyName) && NotNetFramework(assemblyName));
}
bool NotNetFramework(string assemblyName)
{
return(!assemblyName.StartsWith("Microsoft.") &&
!assemblyName.StartsWith("System.") &&
!assemblyName.StartsWith("Newtonsoft.") &&
!assemblyName.StartsWith("netstandard"));
}
void PrepareAssembly(Assembly assembly)
{
foreach (var type in assembly.GetTypes())
{
foreach (var method in type.GetMethods(BindingFlags.DeclaredOnly |
BindingFlags.NonPublic |
BindingFlags.Public | BindingFlags.Instance |
BindingFlags.Static))
{
try
{
if (method.IsAbstract)
{
continue;
}
RuntimeHelpers.PrepareMethod(
method.MethodHandle);
}
catch (Exception e)
{
InternalLogger.GetDefaultLogger().LogError(e, "PreJit: Error with PrepareAssembly");
}
}
}
}
void LoadReferencedAssemblies(Assembly assembly)
{
foreach (AssemblyName an in assembly.GetReferencedAssemblies().Where(x => ShouldLoad(x.FullName)))
{
// Load the assembly and load its dependencies
Assembly loadedAssembly = Assembly.Load(an);
loaded.Add(an.FullName);
PrepareAssembly(loadedAssembly);
LoadReferencedAssemblies(loadedAssembly); // Load the referenced assemblies
}
}
}
public void ctor_EndgameTokens(Menu.Menu menu, MenuObject owner, Vector2 pos, FContainer container, KarmaLadder ladder)
{
//Created Delegate to call Menu.PositionedMenuObject constructor
Type[] constructorSignature = new Type[3];
constructorSignature[0] = typeof(Menu.Menu);
constructorSignature[1] = typeof(Menu.MenuObject);
constructorSignature[2] = typeof(Vector2);
RuntimeMethodHandle handle = typeof(Menu.PositionedMenuObject).GetConstructor(constructorSignature).MethodHandle;
RuntimeHelpers.PrepareMethod(handle);
IntPtr ptr = handle.GetFunctionPointer();
Action <Menu.Menu, Menu.MenuObject, Vector2> funct = (Action <Menu.Menu, Menu.MenuObject, Vector2>)Activator.CreateInstance(typeof(Action <Menu.Menu, Menu.MenuObject, Vector2>), this, ptr);
funct(menu, owner, pos);//Menu.PositionedMenuObject constructor
//Original Code:
this.tokens = new List <EndgameTokens.Token>();
bool flag = false;
this.addPassageButtonWhenTokenBecomesVisible = false;
int num = 0;
for (int i = 0; i < ladder.endGameMeters.Count; i++)
{
if (ladder.endGameMeters[i].fullfilledNow)
{
this.addPassageButtonWhenTokenBecomesVisible = true;
}
if (ladder.endGameMeters[i].tracker.GoalFullfilled && !ladder.endGameMeters[i].tracker.consumed)
{
if (ladder.endGameMeters[i].tracker.GoalAlreadyFullfilled && !flag)
{
flag = true;
}
this.tokens.Add(new EndgameTokens.Token(menu, this, default(Vector2), ladder.endGameMeters[i], container, num));
this.subObjects.Add(this.tokens[this.tokens.Count - 1]);
num++;
}
if (ladder.endGameMeters[i].fullfilledNow)
{
this.forceShowTokenAdd = true;
}
}
// New Code:
if (menu is SleepAndDeathScreen) //To avoid calling menu as SleepAndDeathScreen when menu is MultiplayerSleepAndDeathScreen
{
if ((menu as SleepAndDeathScreen).winState != null)
{
for (int j = 0; j < (menu as SleepAndDeathScreen).winState.endgameTrackers.Count; j++)
{
if (!(menu as SleepAndDeathScreen).winState.endgameTrackers[j].GoalAlreadyFullfilled && (menu as SleepAndDeathScreen).winState.endgameTrackers[j].GoalFullfilled)
{
this.pingAchivements = true;
break;
}
}
}
if (flag)
{
(menu as SleepAndDeathScreen).AddPassageButton(false);
this.addPassageButtonWhenTokenBecomesVisible = false;
}
}
else
{
if ((menu as MultiplayerSleepAndDeathScreen).winState != null)
{
for (int j = 0; j < (menu as MultiplayerSleepAndDeathScreen).winState.endgameTrackers.Count; j++)
{
if (!(menu as MultiplayerSleepAndDeathScreen).winState.endgameTrackers[j].GoalAlreadyFullfilled && (menu as MultiplayerSleepAndDeathScreen).winState.endgameTrackers[j].GoalFullfilled)
{
this.pingAchivements = true;
break;
}
}
}
}
}
public void ctor_MainMenu(ProcessManager manager, bool showRegionSpecificBkg)
{
//Created Delegate to call Menu.Menu constructor
Type[] constructorSignature = new Type[2];
constructorSignature[0] = typeof(ProcessManager);
constructorSignature[1] = typeof(ProcessManager.ProcessID);
RuntimeMethodHandle handle = typeof(Menu.Menu).GetConstructor(constructorSignature).MethodHandle;
RuntimeHelpers.PrepareMethod(handle);
IntPtr ptr = handle.GetFunctionPointer();
Action <ProcessManager, ProcessManager.ProcessID> funct = (Action <ProcessManager, ProcessManager.ProcessID>)Activator.CreateInstance(typeof(Action <ProcessManager, ProcessManager.ProcessID>), this, ptr);
funct(manager, ProcessManager.ProcessID.MainMenu);//Menu.Menu constructor
//Original code:
bool flag = manager.rainWorld.progression.IsThereASavedGame(0);
this.pages.Add(new Page(this, null, "main", 0));
this.scene = new InteractiveMenuScene(this, this.pages[0], (!showRegionSpecificBkg || !flag) ? MenuScene.SceneID.MainMenu : this.BackgroundScene());
this.pages[0].subObjects.Add(this.scene);
float num = 0.3f;
float num2 = 0.5f;
if (this.scene != null)
{
switch (this.scene.sceneID)
{
case MenuScene.SceneID.Landscape_CC:
num = 0.65f;
num2 = 0.65f;
break;
case MenuScene.SceneID.Landscape_DS:
num = 0.5f;
break;
case MenuScene.SceneID.Landscape_GW:
num = 0.45f;
num2 = 0.6f;
break;
case MenuScene.SceneID.Landscape_LF:
num = 0.65f;
num2 = 0.4f;
break;
case MenuScene.SceneID.Landscape_SB:
num = 0f;
num2 = 0f;
break;
case MenuScene.SceneID.Landscape_SH:
num = 0.2f;
num2 = 0.2f;
break;
case MenuScene.SceneID.Landscape_SI:
num = 0.55f;
num2 = 0.75f;
break;
case MenuScene.SceneID.Landscape_SS:
num = 0f;
num2 = 0f;
break;
case MenuScene.SceneID.Landscape_SU:
num = 0.6f;
break;
case MenuScene.SceneID.Landscape_UW:
num = 0f;
num2 = 0f;
break;
}
}
if (num2 > 0f)
{
this.gradientsContainer = new GradientsContainer(this, this.pages[0], new Vector2(0f, 0f), num2);
this.pages[0].subObjects.Add(this.gradientsContainer);
if (num > 0f)
{
this.gradientsContainer.subObjects.Add(new DarkGradient(this, this.gradientsContainer, new Vector2(683f, 580f), 600f, 350f, num));
}
}
float num3 = (base.CurrLang != InGameTranslator.LanguageID.Italian) ? 110f : 150f;
this.pages[0].subObjects.Add(new SimpleButton(this, this.pages[0], base.Translate("SINGLE PLAYER"), "SINGLE PLAYER", new Vector2(683f - num3 / 2f, 370f), new Vector2(num3, 30f)));
//New Code:
this.pages[0].subObjects.Add(new SimpleButton(this, this.pages[0], "MULTIPLAYER", "COOP", new Vector2(683f - num3 / 2f, 330f), new Vector2(num3, 30f))); //Added Multiplayer Button
this.pages[0].subObjects.Add(new SimpleButton(this, this.pages[0], base.Translate("REGIONS"), "REGIONS", new Vector2(683f - num3 / 2f, 290f), new Vector2(num3, 30f))); //and shifted all other buttons down
(this.pages[0].subObjects[this.pages[0].subObjects.Count - 1] as SimpleButton).buttonBehav.greyedOut = !manager.rainWorld.progression.miscProgressionData.IsThereAnyDiscoveredShetlers;
this.pages[0].subObjects.Add(new SimpleButton(this, this.pages[0], base.Translate("ARENA"), "ARENA", new Vector2(683f - num3 / 2f, 250f), new Vector2(num3, 30f)));
this.pages[0].subObjects.Add(new SimpleButton(this, this.pages[0], base.Translate("OPTIONS"), "OPTIONS", new Vector2(683f - num3 / 2f, 210f), new Vector2(num3, 30f)));
this.pages[0].subObjects.Add(new SimpleButton(this, this.pages[0], base.Translate("EXIT"), "EXIT", new Vector2(683f - num3 / 2f, 170f), new Vector2(num3, 30f)));
//Original Code:
this.pages[0].subObjects.Add(new MenuIllustration(this, this.pages[0], string.Empty, "MainTitleShadow", new Vector2(378f, 440f), true, false));
this.pages[0].subObjects.Add(new MenuIllustration(this, this.pages[0], string.Empty, "MainTitleBevel", new Vector2(378f, 440f), true, false));
(this.pages[0].subObjects[this.pages[0].subObjects.Count - 1] as MenuIllustration).sprite.shader = manager.rainWorld.Shaders["MenuText"];
(this.pages[0].subObjects[this.pages[0].subObjects.Count - 1] as MenuIllustration).sprite.color = new Color(0f, 1f, 1f);
for (int i = 0; i < this.pages[0].subObjects.Count; i++)
{
if (this.pages[0].subObjects[i] is SimpleButton)
{
this.pages[0].subObjects[i].nextSelectable[0] = this.pages[0].subObjects[i];
this.pages[0].subObjects[i].nextSelectable[2] = this.pages[0].subObjects[i];
}
}
this.mySoundLoopID = SoundID.MENU_Main_Menu_LOOP;
(this.pages[0].selectables[0] as MenuObject).nextSelectable[1] = (this.pages[0].selectables[this.pages[0].selectables.Count - 1] as MenuObject);
(this.pages[0].selectables[this.pages[0].selectables.Count - 1] as MenuObject).nextSelectable[3] = (this.pages[0].selectables[0] as MenuObject);
if (manager.rainWorld.progression.gameTinkeredWith)
{
float num4 = 10f;
for (float num5 = -310f; num5 < 768f; num5 += 25f)
{
while (num4 < 1366f)
{
this.pages[0].subObjects.Add(new MenuLabel(this, this.pages[0], "The save file or world folder has been tinkered with.", new Vector2(num4, num5), new Vector2(600f, 50f), false));
num4 += 320f;
}
num4 = 0f;
}
}
}
public void SwapMethods()
{
if (swapped)
{
throw new Exception("Methods already patched");
}
swapped = true;
RuntimeHelpers.PrepareMethod(method.MethodHandle);
RuntimeHelpers.PrepareMethod(replacement.MethodHandle);
pBody = method.MethodHandle.GetFunctionPointer();
pBorrowed = replacement.MethodHandle.GetFunctionPointer();
unsafe {
var ptr = (byte * )pBody.ToPointer();
var ptr2 = (byte * )pBorrowed.ToPointer();
var ptrDiff = ptr2 - ptr - 5;
var relativeJumpAvailable = ptrDiff <(long)0xFFFFFFFF && ptrDiff> (long) - 0xFFFFFFFF;
var doNotUseRelativeJump = true; // See issues #69 and #89
Logger.Debug("Relative jump is {0}available \\ {1}bit platform", relativeJumpAvailable ? "" : "not ", sizeof(IntPtr) * 8);
// Backup orignal opcodes so we can revert it later
for (var i = 0; i < backup.Length; i++)
{
backup[i] = *(ptr + i);
}
if (!doNotUseRelativeJump && relativeJumpAvailable)
{
// 32-bit relative jump, available on both 32 and 64 bit arch.
// Debug.Trace($"diff is {ptrDiff} doing relative jmp");
// Debug.Trace("patching on {0:X}, target: {1:X}", (ulong)ptr, (ulong)ptr2);
*ptr = 0xE9; // JMP
*((uint * )(ptr + 1)) = (uint)ptrDiff;
}
else
{
// Debug.Trace($"diff is {ptrDiff} doing push+ret trampoline");
// Debug.Trace("patching on {0:X}, target: {1:X}", (ulong)ptr, (ulong)ptr2);
if (sizeof(IntPtr) == 8)
{
// For 64bit arch and likely 64bit pointers, do:
// PUSH bits 0 - 32 of addr
// MOV [RSP+4] bits 32 - 64 of addr
// RET
var cursor = ptr;
*(cursor++) = 0x68; // PUSH
*((uint * )cursor) = (uint)ptr2;
cursor += 4;
*(cursor++) = 0xC7; // MOV [RSP+4]
*(cursor++) = 0x44;
*(cursor++) = 0x24;
*(cursor++) = 0x04;
*((uint * )cursor) = (uint)((ulong)ptr2 >> 32);
cursor += 4;
*(cursor++) = 0xC3; // RET
}
else
{
// For 32bit arch and 32bit pointers, do: PUSH addr, RET.
*ptr = 0x68;
*((uint * )(ptr + 1)) = (uint)ptr2;
*(ptr + 5) = 0xC3;
}
}
// Logger.Debug("Patched 0x{0:X} to 0x{1:X}.", (ulong)ptr, (ulong)ptr2);
}
}
internal Redirection(MethodBase original, MethodBase replacement, bool start)
{
Original = original;
Replacement = replacement;
// Note: I'm making local copies of the following fields to avoid accessing fields multiple times.
RuntimeMethodHandle originalHandle = original.MethodHandle;
RuntimeMethodHandle replacementHandle = replacement.MethodHandle;
// Fetch their respective start
IntPtr originalStart = Helpers.GetMethodStart(originalHandle);
IntPtr replacementStart = Helpers.GetMethodStart(replacementHandle);
// Edge case: calling this on the same method
if (originalStart == replacementStart)
{
throw new InvalidOperationException("Cannot redirect a method to itself.");
}
// Edge case: methods are too close to one another
int difference = (int)Math.Abs(originalStart.ToInt64() - replacementStart.ToInt64());
int sizeOfPtr = Marshal.SizeOf(typeof(IntPtr));
if ((sizeOfPtr == sizeof(long) && difference < 13) || (sizeOfPtr == sizeof(int) && difference < 7))
{
throw new InvalidOperationException("Unable to redirect methods whose bodies are too close to one another.");
}
// Make sure they're jitted
if (!Helpers.HasBeenCompiled(originalStart))
{
RuntimeHelpers.PrepareMethod(originalHandle);
originalStart = Helpers.GetMethodStart(originalHandle);
}
if (!Helpers.HasBeenCompiled(replacementStart))
{
RuntimeHelpers.PrepareMethod(replacementHandle);
replacementStart = Helpers.GetMethodStart(replacementHandle);
}
// Copy local value to field
originalMethodStart = originalStart;
// In some cases, the memory might need to be readable / writable:
// Make the memory region rw right away just in case.
Helpers.AllowRW(originalStart);
// Save bytes to change to redirect method
byte[] replBytes = replacementBytes = Helpers.GetJmpBytes(replacementStart);
byte[] origBytes = originalBytes = new byte[replBytes.Length];
Marshal.Copy(originalStart, origBytes, 0, origBytes.Length);
if (start)
{
CopyToStart(replBytes, originalStart);
isRedirecting = true;
}
// Save methods in static array to make sure they're not garbage collected
PersistingMethods.Add(original);
PersistingMethods.Add(replacement);
}
public static unsafe bool HookMethod(MethodBase victim, MethodBase dest, out Action unhook)
{
var destAddr = GetMethodAddress(dest);
unhook = null;
//var genericArguments = new Type[0];
//if (victim.DeclaringType.GetGenericArguments() != null)
//{
// genericArguments = victim.DeclaringType.GetGenericArguments().ToArray();
//}
//if (victim.GetGenericArguments() != null)
//{
// genericArguments = genericArguments.Concat(victim.GetGenericArguments()).ToArray();
//}
RuntimeHelpers.PrepareMethod(victim.MethodHandle);
//RuntimeHelpers.PrepareMethod(victim.MethodHandle, victim.DeclaringType.GetGenericArguments().Concat(victim.GetGenericArguments()).Select(type => type.TypeHandle).ToArray());
var victimAddr = GetMethodAddress(victim);
bool canMakeRelJmp;
int dist = 0;
if (IntPtr.Size == 4)
{
canMakeRelJmp = true;
dist = destAddr.ToInt32() - victimAddr.ToInt32() - 5;
}
else
{
var dist64 = destAddr.ToInt64() - victimAddr.ToInt64() - 5;
canMakeRelJmp = dist64 >= int.MinValue && dist64 <= int.MaxValue;
if (canMakeRelJmp)
{
dist = (int)dist64;
}
}
if (canMakeRelJmp)
{
// Make relative jump
var bytes = BitConverter.GetBytes(dist);
var hookCode = new byte[]
{
0xE9, bytes[0], bytes[1], bytes[2], bytes[3], // jmp dest
0x00,
0x00,
0x00,
};
long x = BitConverter.ToInt64(hookCode, 0);
long oldCode;
if (!PlantRelJmpHook(victimAddr, x, out oldCode))
{
return(false);
}
unhook = () =>
{
long tmp;
PlantRelJmpHook(victimAddr, oldCode, out tmp);
};
return(true);
}
else
{
// todo: set unhook delegate
if (compareExchange2Words == null)
{
return(false);
}
// Make absolute jump
UIntPtr lo, hi;
if (IntPtr.Size == 8)
{
// x64
var bytes = BitConverter.GetBytes(destAddr.ToInt64());
var hookCode = new byte[16]
{
0x48, 0xB8, bytes[0], bytes[1], bytes[2], bytes[3],
bytes[4], bytes[5], bytes[6], bytes[7], // movabs rax, hookMethod
0xFF, 0xE0, // jmp rax
0x90, // nop
0x90, // nop
0x90, // nop
0x90 // nop
};
lo = new UIntPtr(BitConverter.ToUInt64(hookCode, 0));
hi = new UIntPtr(BitConverter.ToUInt64(hookCode, 8));
}
else
{
// x86
var bytes = BitConverter.GetBytes(destAddr.ToInt32());
var hookCode = new byte[8]
{
0xB8, bytes[0], bytes[1], bytes[2], bytes[3], // mov eax, hookMethod
0xFF, 0xE0, // jmp eax
0x90 // nop
};
lo = new UIntPtr(BitConverter.ToUInt32(hookCode, 0));
hi = new UIntPtr(BitConverter.ToUInt32(hookCode, 4));
}
MEMORY_PROTECTION_CONSTANTS oldProtect;
if (!VirtualProtect(victimAddr, (uint)(IntPtr.Size * 2), MEMORY_PROTECTION_CONSTANTS.PAGE_EXECUTE_READWRITE, &oldProtect))
{
return(false);
}
compareExchange2Words(victimAddr, lo, hi);
VirtualProtect(victimAddr, (uint)(IntPtr.Size * 2), oldProtect, &oldProtect);
return(true);
}
}
private static void DoPatch()
{
Harmony.DEBUG = true;
var harmony = new Harmony("com.company.project.product");
//Task.Run(() =>
{
//while(true)
{
var original = typeof(Racelogic.Gnss.SatGen.Simulation).GetMethod("CheckFeature",
BindingFlags.NonPublic | BindingFlags.Static);
Console.WriteLine(original);
var prefix =
typeof(Program).GetMethod("CheckFeature_pre", BindingFlags.Static | BindingFlags.NonPublic);
Console.WriteLine(prefix);
var postfix =
typeof(Program).GetMethod("CheckFeature_post", BindingFlags.Static | BindingFlags.NonPublic);
Console.WriteLine(postfix);
//RuntimeHelpers.PrepareMethod(original.MethodHandle);
//harmony.Patch(original, new HarmonyMethod(prefix));
install(original,
typeof(Program).GetMethod("CheckFeature_orig", BindingFlags.Static | BindingFlags.NonPublic));
// Thread.Sleep(5000);
}
} //);
{
//Environment.NewLine
var original = typeof(System.Environment).GetMethod("get_NewLine",
BindingFlags.Public | BindingFlags.Static);
Console.WriteLine(original);
var postfix =
typeof(Program).GetMethod("newline", BindingFlags.Static | BindingFlags.NonPublic);
Console.WriteLine(postfix);
harmony.Patch(original, new HarmonyMethod(postfix));
}
{
//Racelogic.Utilities.WinFileIO
//public void OpenForWriting(string fileName)
var original = typeof(Racelogic.Utilities.WinFileIO).GetMethod("OpenForWriting",
BindingFlags.Public | BindingFlags.Instance);
Console.WriteLine(original);
var prefix =
typeof(Program).GetMethod("OpenForWriting", BindingFlags.Static | BindingFlags.NonPublic);
Console.WriteLine(prefix);
//harmony.Patch(original, new HarmonyMethod(prefix));
install(original, prefix);
}
{
//public bool Close()
var original = typeof(Racelogic.Utilities.WinFileIO).GetMethod("Close",
BindingFlags.Public | BindingFlags.Instance);
Console.WriteLine(original);
var prefix =
typeof(Program).GetMethod("Close", BindingFlags.Static | BindingFlags.NonPublic);
Console.WriteLine(prefix);
RuntimeHelpers.PrepareMethod(original.MethodHandle);
harmony.Patch(original, new HarmonyMethod(prefix));
}
{
//public int WriteBlocks(IntPtr bufferPointer, int numBytesToWrite)
var original = typeof(Racelogic.Utilities.WinFileIO).GetMethods().Where(a => a.Name == "WriteBlocks")
.Last();
Console.WriteLine(original);
var prefix =
typeof(Program).GetMethod("WriteBlocks", BindingFlags.Static | BindingFlags.NonPublic);
Console.WriteLine(prefix);
RuntimeHelpers.PrepareMethod(original.MethodHandle);
harmony.Patch(original, new HarmonyMethod(prefix));
}
Console.WriteLine();
harmony.PatchAll();
var methods = harmony.GetPatchedMethods();
foreach (var method in methods)
{
//...
Console.WriteLine("Patched {0}", method.ToString());
MethodBody mb = method.GetMethodBody();
Console.WriteLine("\r\nMethod: {0}", method);
var il = mb.GetILAsByteArray();
var ans = VRCheat.IL.ILParser.Parse(method);
try
{
foreach (var item in ans)
{
Console.WriteLine(item);
}
}
catch
{
}
//var rd = new ReflectionDisassembler(new PlainTextOutput(), CancellationToken.None);
//rd.DisassembleMethod(new PEFile(,), method.MethodHandle);
}
}
public void Prepare()
{
RuntimeHelpers.PrepareMethod(MethodInfo.MethodHandle);
}
OnAssemblyLoad(
object Sender,
AssemblyLoadEventArgs Args
)
{
//
// STEP1: Wait for Microsoft.PowerShell.Commands.Utility (MPCU)
//
string assemblyName = Args.LoadedAssembly.GetName().Name;
Console.WriteLine("[*] Loading assembly " + assemblyName);
if (assemblyName != "Microsoft.PowerShell.Commands.Utility")
{
return;
}
AppDomain.CurrentDomain.AssemblyLoad -= s_EventHandler;
Assembly mpcuAssembly = Args.LoadedAssembly;
//
// You may want to break into a debugger for debugging.
//
//Debugger.Launch();
//
// STEP2: Find methods via reflection
//
const BindingFlags anyType = BindingFlags.Static |
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.NonPublic;
var targetMethodType = Type.EmptyTypes;
var handlerMethodType = new Type[] { typeof(HookProcessRecord), };
var trampolineMethodType = Type.EmptyTypes;
Type targetMethodClass = mpcuAssembly.GetType(
"Microsoft.PowerShell.Commands.InvokeExpressionCommand");
Type handlerMethodClass = typeof(HookProcessRecord);
Type trampolineMethodClass = typeof(HookProcessRecord);
MethodInfo target = targetMethodClass.GetMethod(
"ProcessRecord",
anyType,
null,
targetMethodType,
null);
MethodInfo hookHandler = handlerMethodClass.GetMethod(
"ProcessRecordHookHandler",
anyType,
null,
handlerMethodType,
null);
MethodInfo trampoline = trampolineMethodClass.GetMethod(
"ProcessRecordTrampoline",
anyType,
null,
trampolineMethodType,
null);
//
// STEP4: Get addresses of native code of the methods
//
RuntimeHelpers.PrepareMethod(target.MethodHandle);
RuntimeHelpers.PrepareMethod(hookHandler.MethodHandle);
RuntimeHelpers.PrepareMethod(trampoline.MethodHandle);
IntPtr targetAddr = target.MethodHandle.GetFunctionPointer();
IntPtr hookHandlerAddr = hookHandler.MethodHandle.GetFunctionPointer();
IntPtr trampolineAddr = trampoline.MethodHandle.GetFunctionPointer();
//
// STEP5: Install a hook on to the target method
//
if (!MinHook.InstallHook(targetAddr, hookHandlerAddr, trampolineAddr))
{
return;
}
//
// STEP6: PROFIT!
//
Console.WriteLine("[*] The ProcessRecord method has been hooked.");
}
public static unsafe void Replace(MethodInfo methodToReplace, MethodInfo methodToInject)
{
var isInjectedMethodDynamic = methodToInject is DynamicMethod;
RuntimeHelpers.PrepareMethod(methodToReplace.MethodHandle);
if (!isInjectedMethodDynamic)
{
RuntimeHelpers.PrepareMethod(methodToInject.MethodHandle);
}
else
{
var dynamicMethodHandle = GetDynamicHandle(methodToInject as DynamicMethod);
RuntimeHelpers.PrepareMethod(dynamicMethodHandle);
}
unsafe
{
if (IntPtr.Size == 4)
{
int *inj = (int *)methodToInject.MethodHandle.Value.ToPointer() + 2;
int *tar = (int *)methodToReplace.MethodHandle.Value.ToPointer() + 2;
#if DEBUG
Console.WriteLine("\nVersion x86 Debug\n");
byte *injInst = (byte *)*inj;
byte *tarInst = (byte *)*tar;
int *injSrc = (int *)(injInst + 1);
int *tarSrc = (int *)(tarInst + 1);
*tarSrc = (((int)injInst + 5) + *injSrc) - ((int)tarInst + 5);
#else
Console.WriteLine("\nVersion x86 Release\n");
*tar = *inj;
#endif
}
else
{
long *inj = isInjectedMethodDynamic
? (long *)GetDynamicHandle(methodToInject as DynamicMethod).Value.ToPointer() + 1
: (long *)methodToInject.MethodHandle.Value.ToPointer() + 1;
long *tar = (long *)methodToReplace.MethodHandle.Value.ToPointer() + 1;
#if DEBUG
Console.WriteLine("\nVersion x64 Debug\n");
//byte* injInst = (byte*)*inj;
//byte* tarInst = (byte*)*tar;
byte *injInst = isInjectedMethodDynamic
? (byte *)GetDynamicHandle(methodToInject as DynamicMethod).GetFunctionPointer()
: (byte *)methodToInject.MethodHandle.GetFunctionPointer();
byte *tarInst = (byte *)methodToReplace.MethodHandle.GetFunctionPointer();
long *injSrc = (long *)(injInst + 1);
long *tarSrc = (long *)(tarInst + 1);
*tarSrc = (((long)injInst + 5) + *injSrc) - ((long)tarInst + 5);
#else
Console.WriteLine("\nVersion x64 Release\n");
*tar = *inj;
#endif
}
}
}
public void ctor(Menu.Menu menu, MenuObject owner)
{
//Delegate to call the base constructor
Type[] constructorSignature = new Type[3];
constructorSignature[0] = typeof(Menu.Menu);
constructorSignature[1] = typeof(MenuObject);
constructorSignature[2] = typeof(Vector2);
RuntimeMethodHandle handle = typeof(Menu.PositionedMenuObject).GetConstructor(constructorSignature).MethodHandle;
RuntimeHelpers.PrepareMethod(handle);
IntPtr ptr = handle.GetFunctionPointer();
Action <Menu.Menu, MenuObject, Vector2> funct = (Action <Menu.Menu, MenuObject, Vector2>)Activator.CreateInstance(typeof(Action <Menu.Menu, MenuObject, Vector2>), this, ptr);
funct(menu, owner, new Vector2(440f, 385f));//RectangularMenuObject Constructor
this.scoreControllers = new List <SandboxSettingsInterface.ScoreController>();
IntVector2 intVector = new IntVector2(0, 0);
//Replaced Code
foreach (patch_MultiplayerUnlocks.SandboxUnlockID creature in patch_MultiplayerUnlocks.CreatureUnlockList)
{
if (creature != patch_MultiplayerUnlocks.SandboxUnlockID.Fly &&
creature != patch_MultiplayerUnlocks.SandboxUnlockID.Leech &&
creature != patch_MultiplayerUnlocks.SandboxUnlockID.SeaLeech &&
creature != patch_MultiplayerUnlocks.SandboxUnlockID.SmallNeedleWorm &&
creature != patch_MultiplayerUnlocks.SandboxUnlockID.Spider &&
creature != patch_MultiplayerUnlocks.SandboxUnlockID.VultureGrub &&
creature != patch_MultiplayerUnlocks.SandboxUnlockID.BigEel &&
creature != patch_MultiplayerUnlocks.SandboxUnlockID.Deer &&
creature != patch_MultiplayerUnlocks.SandboxUnlockID.WalkerBeast &&
creature != patch_MultiplayerUnlocks.SandboxUnlockID.SmallCentipede &&
creature != patch_MultiplayerUnlocks.SandboxUnlockID.TubeWorm &&
creature != patch_MultiplayerUnlocks.SandboxUnlockID.Hazer)
{
this.AddScoreButton((MultiplayerUnlocks.SandboxUnlockID)creature, ref intVector);
}
}
//-=-=-=-=-=-=-=-=-=-=-
//for (int j = 0; j < 1; j++)
//{
// this.AddScoreButton(null, ref intVector);
//}
this.AddScoreButton(new SandboxSettingsInterface.MiscScore(menu, this, menu.Translate("Food"), "FOODSCORE"), ref intVector);
this.AddScoreButton(new SandboxSettingsInterface.MiscScore(menu, this, menu.Translate("Survive"), "SURVIVESCORE"), ref intVector);
this.AddScoreButton(new SandboxSettingsInterface.MiscScore(menu, this, menu.Translate("Spear hit"), "SPEARHITSCORE"), ref intVector);
if (menu.CurrLang != InGameTranslator.LanguageID.English)
{
for (int k = 1; k < 4; k++)
{
SandboxSettingsInterface.ScoreController scoreController = this.scoreControllers[this.scoreControllers.Count - k];
scoreController.pos.x = scoreController.pos.x + 24f;
}
}
this.subObjects.Add(new SymbolButton(menu, this, "Menu_Symbol_Clear_All", "CLEARSCORES", new Vector2(0f, -280f)));
for (int l = 0; l < this.subObjects.Count; l++)
{
if (this.subObjects[l] is SandboxSettingsInterface.ScoreController)
{
(this.subObjects[l] as SandboxSettingsInterface.ScoreController).scoreDragger.UpdateScoreText();
}
}
}
private void DisassembleAndWriteSimpleMethod(JitWriteContext context, MethodBase method)
{
var handle = method.MethodHandle;
RuntimeHelpers.PrepareMethod(handle);
var clrMethod = context.Runtime.GetMethodByHandle((ulong)handle.Value.ToInt64());
var regions = FindNonEmptyHotColdInfo(clrMethod);
if (clrMethod == null || regions == null)
{
context.Runtime.Flush();
clrMethod = context.Runtime.GetMethodByHandle((ulong)handle.Value.ToInt64());
regions = FindNonEmptyHotColdInfo(clrMethod);
}
if (clrMethod == null || regions == null)
{
var address = (ulong)handle.GetFunctionPointer().ToInt64();
clrMethod = context.Runtime.GetMethodByAddress(address);
regions = FindNonEmptyHotColdInfo(clrMethod);
}
var writer = context.Writer;
if (clrMethod != null)
{
writer.WriteLine();
writer.WriteLine(clrMethod.GetFullSignature());
}
else
{
WriteSignatureFromReflection(context, method);
}
if (regions == null)
{
if (method.IsGenericMethod || (method.DeclaringType?.IsGenericType ?? false))
{
writer.WriteLine(" ; Failed to find HotColdInfo for generic method (reference types?).");
return;
}
writer.WriteLine(" ; Failed to find HotColdRegions.");
return;
}
var methodAddress = regions.HotStart;
var methodLength = regions.HotSize;
var reader = new MemoryCodeReader(new IntPtr(unchecked ((long)methodAddress)), methodLength);
var decoder = Decoder.Create(MapArchitectureToBitness(context.Runtime.DataTarget.Architecture), reader);
var instructions = new InstructionList();
decoder.IP = methodAddress;
while (decoder.IP < (methodAddress + methodLength))
{
decoder.Decode(out instructions.AllocUninitializedElement());
}
var resolver = new JitAsmSymbolResolver(context.Runtime, methodAddress, methodLength);
var formatter = new IntelFormatter(FormatterOptions, resolver);
var output = new StringOutput();
foreach (ref var instruction in instructions)
{
formatter.Format(instruction, output);
writer.Write(" L");
writer.Write((instruction.IP - methodAddress).ToString("x4"));
writer.Write(": ");
writer.WriteLine(output.ToStringAndReset());
}
}
static internal void Prepare(this MethodBase method)
{
RuntimeHelpers.PrepareMethod(method.MethodHandle());
}
public void Update(bool eu)
{
if ((this.abstractPhysicalObject as patch_AbstractPhysicalObject).networkObject)
{
if (this.lungsExhausted)
{
this.aerobicLevel = 1f;
}
else
{
this.aerobicLevel = Mathf.Max(1f - this.airInLungs, this.aerobicLevel - ((!this.slugcatStats.malnourished) ? 1f : 1.2f) / (((this.input[0].x != 0 || this.input[0].y != 0) ? 1100f : 400f) * (1f + 3f * Mathf.InverseLerp(0.9f, 1f, this.aerobicLevel))));
}
if (this.cantBeGrabbedCounter > 0)
{
this.cantBeGrabbedCounter--;
}
if (this.poleSkipPenalty > 0)
{
this.poleSkipPenalty--;
}
if (this.shootUpCounter > 0)
{
this.noGrabCounter = Math.Max(this.noGrabCounter, 2);
this.shootUpCounter--;
if (!this.input[0].jmp || this.input[0].y < 1 || base.mainBodyChunk.pos.y < base.mainBodyChunk.lastPos.y)
{
this.shootUpCounter = 0;
}
}
if (this.bodyMode == Player.BodyModeIndex.ZeroG)
{
this.privSneak = 0.5f;
base.bodyChunks[0].loudness = 0.5f * this.slugcatStats.loudnessFac;
base.bodyChunks[1].loudness = 0.5f * this.slugcatStats.loudnessFac;
}
else
{
if ((!this.standing || this.bodyMode == Player.BodyModeIndex.Crawl || this.bodyMode == Player.BodyModeIndex.CorridorClimb || this.bodyMode == Player.BodyModeIndex.ClimbIntoShortCut || (this.animation == Player.AnimationIndex.HangFromBeam && this.input[0].x == 0) || (this.animation == Player.AnimationIndex.ClimbOnBeam && this.input[0].y == 0)) && this.bodyMode != Player.BodyModeIndex.Default)
{
this.privSneak = Mathf.Min(this.privSneak + 0.1f, 1f);
}
else
{
this.privSneak = Mathf.Max(this.privSneak - 0.04f, 0f);
}
base.bodyChunks[0].loudness = 1.5f * (1f - this.Sneak) * this.slugcatStats.loudnessFac;
base.bodyChunks[1].loudness = 0.7f * (1f - this.Sneak) * this.slugcatStats.loudnessFac;
}
SoundID soundID = SoundID.None;
if (this.Adrenaline > 0.5f)
{
soundID = SoundID.Mushroom_Trip_LOOP;
}
else if (base.Stunned)
{
soundID = SoundID.UI_Slugcat_Stunned_LOOP;
}
else if (this.corridorDrop || this.verticalCorridorSlideCounter > 0 || this.horizontalCorridorSlideCounter > 0)
{
soundID = SoundID.Slugcat_Slide_In_Narrow_Corridor_LOOP;
}
else if (this.slideCounter > 0 && this.bodyMode == Player.BodyModeIndex.Stand)
{
soundID = SoundID.Slugcat_Skid_On_Ground_LOOP;
}
else if (this.animation == Player.AnimationIndex.Roll)
{
soundID = SoundID.Slugcat_Roll_LOOP;
}
else if (this.animation == Player.AnimationIndex.ClimbOnBeam && this.input[0].y < 0)
{
soundID = SoundID.Slugcat_Slide_Down_Vertical_Beam_LOOP;
}
else if (this.animation == Player.AnimationIndex.BellySlide)
{
soundID = SoundID.Slugcat_Belly_Slide_LOOP;
}
else if (this.bodyMode == Player.BodyModeIndex.WallClimb)
{
soundID = SoundID.Slugcat_Wall_Slide_LOOP;
}
if (soundID != this.slideLoopSound)
{
if (this.slideLoop != null)
{
this.slideLoop.alive = false;
this.slideLoop = null;
}
this.slideLoopSound = soundID;
if (this.slideLoopSound != SoundID.None)
{
this.slideLoop = this.room.PlaySound(this.slideLoopSound, base.mainBodyChunk, true, 1f, 1f);
this.slideLoop.requireActiveUpkeep = true;
}
}
if (this.slideLoop != null)
{
this.slideLoop.alive = true;
SoundID soundID2 = this.slideLoopSound;
switch (soundID2)
{
case SoundID.Slugcat_Slide_Down_Vertical_Beam_LOOP:
this.slideLoop.pitch = Mathf.Lerp(0.7f, 1.3f, Mathf.Abs(base.mainBodyChunk.vel.y) / 4.9f);
this.slideLoop.volume = Mathf.Min(1f, Mathf.Abs(base.mainBodyChunk.vel.y) / 2.5f);
break;
default:
if (soundID2 != SoundID.Slugcat_Belly_Slide_LOOP)
{
if (soundID2 != SoundID.Slugcat_Roll_LOOP)
{
if (soundID2 != SoundID.Slugcat_Wall_Slide_LOOP)
{
if (soundID2 != SoundID.Slugcat_Slide_In_Narrow_Corridor_LOOP)
{
if (soundID2 != SoundID.UI_Slugcat_Stunned_LOOP)
{
if (soundID2 == SoundID.Mushroom_Trip_LOOP)
{
this.slideLoop.pitch = 1f;
this.slideLoop.volume = Mathf.InverseLerp(0f, 0.3f, this.Adrenaline);
}
}
else
{
this.slideLoop.pitch = 0.5f + Mathf.InverseLerp(11f, (float)this.lastStun, (float)base.stun);
this.slideLoop.volume = Mathf.Pow(Mathf.InverseLerp(8f, 27f, (float)base.stun), 0.7f);
}
}
else
{
this.slideLoop.pitch = Mathf.Lerp(0.7f, 1.3f, base.mainBodyChunk.vel.magnitude / ((!this.corridorDrop) ? 12.5f : 25f));
if (this.verticalCorridorSlideCounter > 0)
{
this.slideLoop.volume = 1f;
}
else
{
this.slideLoop.volume = Mathf.Min(1f, base.mainBodyChunk.vel.magnitude / 4f);
}
}
}
else
{
this.slideLoop.pitch = Mathf.Lerp(0.7f, 1.3f, Mathf.Abs(base.mainBodyChunk.pos.y - base.mainBodyChunk.lastPos.y) / 1.75f);
this.slideLoop.volume = Mathf.Min(1f, Mathf.Abs(base.mainBodyChunk.vel.y) * 1.5f);
}
}
else
{
this.slideLoop.pitch = Mathf.Lerp(0.85f, 1.15f, 0.5f + Custom.DirVec(base.mainBodyChunk.pos, base.bodyChunks[1].pos).y * 0.5f);
this.slideLoop.volume = 0.5f + Mathf.Abs(Custom.DirVec(base.mainBodyChunk.pos, base.bodyChunks[1].pos).x) * 0.5f;
}
}
else
{
this.slideLoop.pitch = Mathf.Lerp(0.5f, 1.5f, Mathf.Abs(base.mainBodyChunk.vel.x) / 25.5f);
this.slideLoop.volume = Mathf.Min(1f, Mathf.Abs(base.mainBodyChunk.vel.x) / 10f);
}
break;
case SoundID.Slugcat_Skid_On_Ground_LOOP:
this.slideLoop.pitch = Mathf.Lerp(0.7f, 1.3f, Mathf.Abs(base.mainBodyChunk.vel.x) / 9.5f);
this.slideLoop.volume = Mathf.Min(1f, Mathf.Abs(base.mainBodyChunk.vel.x) / 6f);
break;
}
}
if (this.dontGrabStuff > 0)
{
this.dontGrabStuff--;
}
if (this.bodyMode == Player.BodyModeIndex.CorridorClimb)
{
this.timeSinceInCorridorMode = 0;
}
else
{
this.timeSinceInCorridorMode++;
}
if (base.stun == 12)
{
this.room.PlaySound(SoundID.UI_Slugcat_Exit_Stun, base.mainBodyChunk);
}
bool flag = this.input[0].jmp && !this.input[1].jmp;
if (flag)
{
if (base.grasps[0] != null && base.grasps[0].grabbed is TubeWorm)
{
flag = (base.grasps[0].grabbed as TubeWorm).JumpButton(this);
}
else if (base.grasps[1] != null && base.grasps[1].grabbed is TubeWorm)
{
flag = (base.grasps[1].grabbed as TubeWorm).JumpButton(this);
}
}
if (this.canWallJump > 0)
{
this.canWallJump--;
}
else if (this.canWallJump < 0)
{
this.canWallJump++;
}
if (this.jumpChunkCounter > 0)
{
this.jumpChunkCounter--;
}
else if (this.jumpChunkCounter < 0)
{
this.jumpChunkCounter++;
}
if (this.noGrabCounter > 0)
{
this.noGrabCounter--;
}
if (this.waterJumpDelay > 0)
{
this.waterJumpDelay--;
}
if (this.forceFeetToHorizontalBeamTile > 0)
{
this.forceFeetToHorizontalBeamTile--;
}
if (this.canJump > 0)
{
this.canJump--;
}
if (this.slowMovementStun > 0)
{
this.slowMovementStun--;
}
if (this.backwardsCounter > 0)
{
this.backwardsCounter--;
}
if (this.landingDelay > 0)
{
this.landingDelay--;
}
if (this.verticalCorridorSlideCounter > 0)
{
this.verticalCorridorSlideCounter--;
}
if (this.horizontalCorridorSlideCounter > 0)
{
this.horizontalCorridorSlideCounter--;
}
if (this.jumpStun > 0)
{
this.jumpStun--;
}
else if (this.jumpStun < 0)
{
this.jumpStun++;
}
if (this.input[0].downDiagonal != 0 && this.input[0].downDiagonal == this.input[1].downDiagonal)
{
this.consistentDownDiagonal++;
}
else
{
this.consistentDownDiagonal = 0;
}
if (base.dead)
{
this.animation = Player.AnimationIndex.Dead;
this.bodyMode = Player.BodyModeIndex.Dead;
}
else if (base.stun > 0)
{
this.animation = Player.AnimationIndex.None;
this.bodyMode = Player.BodyModeIndex.Stunned;
}
if (this.bodyMode != Player.BodyModeIndex.Swimming)
{
if (base.bodyChunks[0].ContactPoint.x != 0 && this.input[0].x == base.bodyChunks[0].ContactPoint.x && base.bodyChunks[0].vel.y < 0f && this.bodyMode != Player.BodyModeIndex.CorridorClimb)
{
BodyChunk bodyChunk3 = base.bodyChunks[0];
bodyChunk3.vel.y = bodyChunk3.vel.y * Mathf.Clamp(1f - this.surfaceFriction * ((base.bodyChunks[0].pos.y <= base.bodyChunks[1].pos.y) ? 0.5f : 2f), 0f, 1f);
}
if (base.bodyChunks[1].ContactPoint.x != 0 && this.input[0].x == base.bodyChunks[1].ContactPoint.x && base.bodyChunks[1].vel.y < 0f && this.bodyMode != Player.BodyModeIndex.CorridorClimb)
{
BodyChunk bodyChunk4 = base.bodyChunks[1];
bodyChunk4.vel.y = bodyChunk4.vel.y * Mathf.Clamp(1f - this.surfaceFriction * ((base.bodyChunks[0].pos.y <= base.bodyChunks[1].pos.y) ? 0.5f : 2f), 0f, 1f);
}
}
//Created Delegate to call base Update(eu)
RuntimeMethodHandle handle = typeof(Creature).GetMethod("Update").MethodHandle;
RuntimeHelpers.PrepareMethod(handle);
IntPtr ptr = handle.GetFunctionPointer();
Action <bool> funct = (Action <bool>)Activator.CreateInstance(typeof(Action <bool>), this, ptr);
funct(eu);//Creature.Update(eu)
if (base.stun < 1 && !base.dead && this.enteringShortCut == null && !base.inShortcut)
{
this.MovementUpdate(eu);
}
bool flag2 = false;
if (this.input[0].jmp && !this.input[1].jmp && !this.lastWiggleJump)
{
this.wiggle += 0.025f;
this.lastWiggleJump = true;
}
IntVector2 intVector = this.wiggleDirectionCounters;
if (this.input[0].x != 0 && this.input[0].x != this.input[1].x && this.input[0].x != this.lastWiggleDir.x)
{
flag2 = true;
if (intVector.y > 0)
{
this.wiggle += 0.0333333351f;
this.wiggleDirectionCounters.y = this.wiggleDirectionCounters.y - 1;
}
this.lastWiggleDir.x = this.input[0].x;
this.lastWiggleJump = false;
if (this.wiggleDirectionCounters.x < 5)
{
this.wiggleDirectionCounters.x = this.wiggleDirectionCounters.x + 1;
}
}
if (this.input[0].y != 0 && this.input[0].y != this.input[1].y && this.input[0].y != this.lastWiggleDir.y)
{
flag2 = true;
if (intVector.x > 0)
{
this.wiggle += 0.0333333351f;
this.wiggleDirectionCounters.x = this.wiggleDirectionCounters.x - 1;
}
this.lastWiggleDir.y = this.input[0].y;
this.lastWiggleJump = false;
if (this.wiggleDirectionCounters.y < 5)
{
this.wiggleDirectionCounters.y = this.wiggleDirectionCounters.y + 1;
}
}
if (flag2)
{
this.noWiggleCounter = 0;
}
else
{
this.noWiggleCounter++;
}
this.wiggle -= Custom.LerpMap((float)this.noWiggleCounter, 5f, 35f, 0f, 0.0333333351f);
if (this.noWiggleCounter > 20)
{
if (this.wiggleDirectionCounters.x > 0)
{
this.wiggleDirectionCounters.x = this.wiggleDirectionCounters.x - 1;
}
if (this.wiggleDirectionCounters.y > 0)
{
this.wiggleDirectionCounters.y = this.wiggleDirectionCounters.y - 1;
}
}
this.wiggle = Mathf.Clamp(this.wiggle, 0f, 1f);
if (networkLife > 0)
{
networkLife--;
}
else
{
this.RemoveFromRoom();
this.Abstractize();
this.abstractPhysicalObject.Destroy();
this.Destroy();
}
}
else
{
orig_Update(eu);
}
}
/// <summary>
/// 确保函数在JIT机制内，被编译为本地代码
/// </summary>
/// <param name="method"></param>
public static void JIT(MethodBase method)
{
var typeHandles = method.DeclaringType.GetGenericArguments().Select(t => t.TypeHandle).ToArray();
RuntimeHelpers.PrepareMethod(method.MethodHandle, typeHandles);
}
protected virtual void PrepareMethod(MethodBase method, RuntimeMethodHandle handle)
=> RuntimeHelpers.PrepareMethod(handle);
public static void ReplaceMethod(MethodInfo source, MethodInfo destination)
{
if (source == destination)
{
return;
}
RuntimeHelpers.PrepareMethod(source.MethodHandle);
RuntimeHelpers.PrepareMethod(destination.MethodHandle);
// Only 64 bit
if (source.IsVirtual)
{
unsafe
{
var methodDesc = (ulong *)source.MethodHandle.Value.ToPointer();
int index = (int)(((*methodDesc) >> 32) & 0xFF);
//if (IntPtr.Size == 4)
//{
// var classStart = (uint*)source.DeclaringType.TypeHandle.Value.ToPointer();
// classStart += 10;
// classStart = (uint*)*classStart;
// var tar = classStart + index;
// var inj = (uint*)destination.MethodHandle.Value.ToPointer() + 2;
// *tar = *inj;
//}
//else
//{
var classStart = (ulong *)source.DeclaringType.TypeHandle.Value.ToPointer();
classStart += 8;
classStart = (ulong *)*classStart;
var tar = classStart + index;
var inj = (ulong *)destination.MethodHandle.Value.ToPointer() + 1;
* tar = *inj;
//}
}
return;
}
unsafe
{
// if (IntPtr.Size == 4)
// {
// var inj = (int*)destination.MethodHandle.Value.ToPointer() + 2;
// var tar = (int*)source.MethodHandle.Value.ToPointer() + 2;
//#if DEBUG
// var injInst = (byte*)*inj;
// var tarInst = (byte*)*tar;
// var injSrc = (int*)(injInst + 1);
// var tarSrc = (int*)(tarInst + 1);
// *tarSrc = ((int)injInst + 5) + *injSrc - ((int)tarInst + 5);
//#else
// *tar = *inj;
//#endif
// }
// else
// {
var inj = (long *)destination.MethodHandle.Value.ToPointer() + 1;
var tar = (long *)source.MethodHandle.Value.ToPointer() + 1;
* tar = *inj;
//}
}
}
protected virtual void PrepareMethod(MethodBase method, RuntimeMethodHandle handle, RuntimeTypeHandle[] instantiation)
=> RuntimeHelpers.PrepareMethod(handle, instantiation);
public async Task <int> ExecuteCommand(CommandSettings command)
{
ArgUtil.NotNull(command, nameof(command));
try
{
var agentWebProxy = HostContext.GetService <IVstsAgentWebProxy>();
var agentCertManager = HostContext.GetService <IAgentCertificateManager>();
VssUtil.InitializeVssClientSettings(HostContext.UserAgent, agentWebProxy.WebProxy, agentCertManager.VssClientCertificateManager);
_inConfigStage = true;
_completedCommand.Reset();
_term.CancelKeyPress += CtrlCHandler;
//register a SIGTERM handler
HostContext.Unloading += Agent_Unloading;
// TODO Unit test to cover this logic
Trace.Info(nameof(ExecuteCommand));
var configManager = HostContext.GetService <IConfigurationManager>();
// command is not required, if no command it just starts if configured
// TODO: Invalid config prints usage
if (command.IsHelp())
{
PrintUsage(command);
return(Constants.Agent.ReturnCode.Success);
}
if (command.IsVersion())
{
_term.WriteLine(BuildConstants.AgentPackage.Version);
return(Constants.Agent.ReturnCode.Success);
}
if (command.IsCommit())
{
_term.WriteLine(BuildConstants.Source.CommitHash);
return(Constants.Agent.ReturnCode.Success);
}
if (command.IsDiagnostics())
{
PrintBanner();
_term.WriteLine("Running Diagnostics Only...");
_term.WriteLine(string.Empty);
DiagnosticTests diagnostics = new DiagnosticTests(_term);
diagnostics.Execute();
return(Constants.Agent.ReturnCode.Success);
}
// Configure agent prompt for args if not supplied
// Unattend configure mode will not prompt for args if not supplied and error on any missing or invalid value.
if (command.IsConfigureCommand())
{
PrintBanner();
try
{
await configManager.ConfigureAsync(command);
return(Constants.Agent.ReturnCode.Success);
}
catch (Exception ex)
{
Trace.Error(ex);
_term.WriteError(ex.Message);
return(Constants.Agent.ReturnCode.TerminatedError);
}
}
// remove config files, remove service, and exit
if (command.IsRemoveCommand())
{
try
{
await configManager.UnconfigureAsync(command);
return(Constants.Agent.ReturnCode.Success);
}
catch (Exception ex)
{
Trace.Error(ex);
_term.WriteError(ex.Message);
return(Constants.Agent.ReturnCode.TerminatedError);
}
}
_inConfigStage = false;
// warmup agent process (JIT/CLR)
// In scenarios where the agent is single use (used and then thrown away), the system provisioning the agent can call `agent.listener --warmup` before the machine is made available to the pool for use.
// this will optimizes the agent process startup time.
if (command.IsWarmupCommand())
{
var binDir = HostContext.GetDirectory(WellKnownDirectory.Bin);
foreach (var assemblyFile in Directory.EnumerateFiles(binDir, "*.dll"))
{
try
{
Trace.Info($"Load assembly: {assemblyFile}.");
var assembly = Assembly.LoadFrom(assemblyFile);
var types = assembly.GetTypes();
foreach (Type loadedType in types)
{
try
{
Trace.Info($"Load methods: {loadedType.FullName}.");
var methods = loadedType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);
foreach (var method in methods)
{
if (!method.IsAbstract && !method.ContainsGenericParameters)
{
Trace.Verbose($"Prepare method: {method.Name}.");
RuntimeHelpers.PrepareMethod(method.MethodHandle);
}
}
}
catch (Exception ex)
{
Trace.Error(ex);
}
}
}
catch (Exception ex)
{
Trace.Error(ex);
}
}
return(Constants.Agent.ReturnCode.Success);
}
AgentSettings settings = configManager.LoadSettings();
var store = HostContext.GetService <IConfigurationStore>();
bool configuredAsService = store.IsServiceConfigured();
// Run agent
//if (command.Run) // this line is current break machine provisioner.
//{
// Error if agent not configured.
if (!configManager.IsConfigured())
{
_term.WriteError(StringUtil.Loc("AgentIsNotConfigured"));
PrintUsage(command);
return(Constants.Agent.ReturnCode.TerminatedError);
}
Trace.Verbose($"Configured as service: '{configuredAsService}'");
//Get the startup type of the agent i.e., autostartup, service, manual
StartupType startType;
var startupTypeAsString = command.GetStartupType();
if (string.IsNullOrEmpty(startupTypeAsString) && configuredAsService)
{
// We need try our best to make the startup type accurate
// The problem is coming from agent autoupgrade, which result an old version service host binary but a newer version agent binary
// At that time the servicehost won't pass --startuptype to agent.listener while the agent is actually running as service.
// We will guess the startup type only when the agent is configured as service and the guess will based on whether STDOUT/STDERR/STDIN been redirect or not
Trace.Info($"Try determine agent startup type base on console redirects.");
startType = (Console.IsErrorRedirected && Console.IsInputRedirected && Console.IsOutputRedirected) ? StartupType.Service : StartupType.Manual;
}
else
{
if (!Enum.TryParse(startupTypeAsString, true, out startType))
{
Trace.Info($"Could not parse the argument value '{startupTypeAsString}' for StartupType. Defaulting to {StartupType.Manual}");
startType = StartupType.Manual;
}
}
Trace.Info($"Set agent startup type - {startType}");
HostContext.StartupType = startType;
if (PlatformUtil.RunningOnWindows)
{
if (store.IsAutoLogonConfigured())
{
if (HostContext.StartupType != StartupType.Service)
{
Trace.Info($"Autologon is configured on the machine, dumping all the autologon related registry settings");
var autoLogonRegManager = HostContext.GetService <IAutoLogonRegistryManager>();
autoLogonRegManager.DumpAutoLogonRegistrySettings();
}
else
{
Trace.Info($"Autologon is configured on the machine but current Agent.Listner.exe is launched from the windows service");
}
}
}
// Run the agent interactively or as service
return(await RunAsync(settings, command.GetRunOnce()));
}
finally
{
_term.CancelKeyPress -= CtrlCHandler;
HostContext.Unloading -= Agent_Unloading;
_completedCommand.Set();
}
}
public static MethodInfo Prepare(this MethodInfo method)
{
RuntimeHelpers.PrepareMethod(method.MethodHandle);
return(method);
}