/// <summary> /// Checks whether an instance of <see cref="ReloadedFunctionAttribute"/> has the same logical meaning /// as the current instance of <see cref="ReloadedFunctionAttribute"/>. /// </summary> /// <param name="obj">The <see cref="ReloadedFunctionAttribute"/> to compare to the current attribute.</param> /// <returns>True if both of the ReloadedFunctions are logically equivalent.</returns> public override bool Equals(Object obj) { // Check for type. ReloadedFunctionAttribute functionAttribute = obj as ReloadedFunctionAttribute; // Return false if null if (functionAttribute == null) { return(false); } // Check by value. return(functionAttribute.Cleanup == Cleanup && functionAttribute.ReturnRegister == ReturnRegister && functionAttribute.SourceRegisters.SequenceEqual(SourceRegisters)); }
/// <summary> /// Creates the wrapper function for redirecting program flow to our C# function. /// </summary> /// <param name="functionAddress">The address of the function to create a wrapper for.</param> /// <returns></returns> internal static IntPtr CreateReverseWrapperInternal <TFunction>(IntPtr functionAddress, ReloadedFunctionAttribute reloadedFunction) { // Retrieve number of parameters. int numberOfParameters = FunctionCommon.GetNumberofParameters(typeof(TFunction)); int nonRegisterParameters = numberOfParameters - reloadedFunction.SourceRegisters.Length; // List of ASM Instructions to be Compiled List <string> assemblyCode = new List <string> { "use32" }; // Backup Stack Frame assemblyCode.Add("push ebp"); // Backup old call frame assemblyCode.Add("mov ebp, esp"); // Setup new call frame // Push registers for our C# method as necessary. assemblyCode.AddRange(AssembleFunctionParameters(numberOfParameters, reloadedFunction.SourceRegisters)); // Call C# Function Pointer (cSharpFunctionPointer is address at which our C# function address is written) IntPtr cSharpFunctionPointer = MemoryBufferManager.Add(functionAddress, IntPtr.Zero); assemblyCode.Add("call dword [0x" + cSharpFunctionPointer.ToString("X") + "]"); // Restore stack pointer + stack frame assemblyCode.Add($"add esp, {numberOfParameters * 4}"); // MOV our own return register, EAX into the register expected by the calling convention assemblyCode.Add($"mov {reloadedFunction.ReturnRegister}, eax"); // Restore Stack Frame and Return assemblyCode.Add("pop ebp"); // Caller/Callee Cleanup if (reloadedFunction.Cleanup == ReloadedFunctionAttribute.StackCleanup.Callee) { assemblyCode.Add($"ret {nonRegisterParameters * 4}"); } else { assemblyCode.Add("ret"); } // Assemble and return pointer to code byte[] assembledMnemonics = Assembler.Assembler.Assemble(assemblyCode.ToArray()); return(MemoryBufferManager.Add(assembledMnemonics)); }
/// <summary> /// Creates the wrapper function that wraps a native function with our own defined or custom calling convention, /// into a regular CDECL function that is natively supported by the C# programming language. /// /// The return value is a pointer to a C# compatible CDECL fcuntion that calls our game function. /// /// This allows us to call non-standard "usercall" game functions, such as for example functions that take values /// in registers as parameters instead of using the stack, functions which take paremeters in a mixture of both stack /// and registers as well as functions which varying return parameters, either caller or callee cleaned up. /// </summary> /// <param name="functionAddress">The address of the function to create a wrapper for.</param> /// <param name="reloadedFunction">Structure containing the details of the actual function in question.</param> /// <returns>Pointer to the new CDECL function address to call from C# code to invoke our game function.</returns> private static IntPtr CreateWrapperFunctionInternal <TFunction>(IntPtr functionAddress, ReloadedFunctionAttribute reloadedFunction) { // Retrieve number of parameters. int numberOfParameters = FunctionCommon.GetNumberofParameters(typeof(TFunction)); int nonRegisterParameters = numberOfParameters - reloadedFunction.SourceRegisters.Length; // List of ASM Instructions to be Compiled List <string> assemblyCode = new List <string> { "use32" }; // Backup Stack Frame assemblyCode.Add("push ebp"); // Backup old call frame assemblyCode.Add("mov ebp, esp"); // Setup new call frame // Reserve Extra Stack Space if (reloadedFunction.ReservedStackSpace > 0) { assemblyCode.Add($"sub esp, {reloadedFunction.ReservedStackSpace}"); } // Setup Function Parameters if (numberOfParameters > 0) { assemblyCode.AddRange(AssembleFunctionParameters(numberOfParameters, reloadedFunction.SourceRegisters)); } // Call Game Function Pointer (gameFunctionPointer is address at which our function address is written) IntPtr gameFunctionPointer = MemoryBufferManager.Add(functionAddress, IntPtr.Zero); assemblyCode.Add("call dword [0x" + gameFunctionPointer.ToString("X") + "]"); // Stack cleanup if necessary // Move back the stack pointer to before our pushed parameters if (nonRegisterParameters > 0 && reloadedFunction.Cleanup == ReloadedFunctionAttribute.StackCleanup.Caller) { int stackCleanupBytes = 4 * nonRegisterParameters; assemblyCode.Add($"add esp, {stackCleanupBytes}"); } if (reloadedFunction.ReturnRegister != ReloadedFunctionAttribute.Register.eax) { // MOV Game's custom calling convention return register into our return register, EAX. assemblyCode.Add("mov eax, " + reloadedFunction.ReturnRegister); } // Unreserve Extra Stack Space if (reloadedFunction.ReservedStackSpace > 0) { assemblyCode.Add($"add esp, {reloadedFunction.ReservedStackSpace}"); } // Restore Stack Frame and Return assemblyCode.Add("pop ebp"); assemblyCode.Add("ret"); // Write function to buffer and return pointer. byte[] assembledMnemonics = Assembler.Assembler.Assemble(assemblyCode.ToArray()); return(MemoryBufferManager.Add(assembledMnemonics)); }