Replaced NativeHelper with CoreFunctionsManager.

Author: KN4CK3R

Core/CoreFunctionsManager.cs

@@ -0,0 +1,170 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using System.Linq;
+using ReClassNET.Debugger;
+using ReClassNET.Memory;
+using ReClassNET.Native;
+using ReClassNET.Util;
+
+namespace ReClassNET.Core
+{
+	public class CoreFunctionsManager : IDisposable
+	{
+		private const string CoreFunctionsModuleWindows = "NativeHelper.dll";
+		private const string CoreFunctionsModuleUnix = "NativeHelper.so";
+
+		private readonly Dictionary<string, ICoreProcessFunctions> functionsRegistry = new Dictionary<string, ICoreProcessFunctions>();
+
+		public IEnumerable<string> FunctionProviders => functionsRegistry.Keys;
+
+		private IntPtr internalCoreFunctionsHandle;
+
+		private readonly InternalCoreFunctions internalCoreFunctions;
+
+		private ICoreProcessFunctions currentFunctions;
+
+		public CoreFunctionsManager()
+		{
+			internalCoreFunctionsHandle = NativeMethods.LoadLibrary(
+				NativeMethods.IsUnix()
+				? CoreFunctionsModuleUnix
+				: CoreFunctionsModuleWindows
+			);
+
+			if (internalCoreFunctionsHandle.IsNull())
+			{
+				throw new Exception();
+			}
+
+			internalCoreFunctions = new InternalCoreFunctions(internalCoreFunctionsHandle);
+
+			RegisterFunctions("Default", internalCoreFunctions);
+
+			currentFunctions = internalCoreFunctions;
+		}
+
+		#region IDisposable Support
+
+		~CoreFunctionsManager()
+		{
+			Dispose(false);
+		}
+
+		protected virtual void Dispose(bool disposing)
+		{
+			if (!internalCoreFunctionsHandle.IsNull())
+			{
+				NativeMethods.FreeLibrary(internalCoreFunctionsHandle);
+
+				internalCoreFunctionsHandle = IntPtr.Zero;
+			}
+		}
+
+		public void Dispose()
+		{
+			Dispose(true);
+
+			GC.SuppressFinalize(this);
+		}
+
+		#endregion
+
+		public void RegisterFunctions(string provider, ICoreProcessFunctions functions)
+		{
+			Contract.Requires(provider != null);
+			Contract.Requires(functions != null);
+
+			functionsRegistry.Add(provider, functions);
+		}
+
+		public void SetActiveFunctionsProvider(string provider)
+		{
+			ICoreProcessFunctions functions;
+			if (!functionsRegistry.TryGetValue(provider, out functions))
+			{
+				throw new ArgumentException();
+			}
+
+			currentFunctions = functions;
+		}
+
+		#region Plugin Functions
+
+		public void EnumerateProcesses(Action<Tuple<IntPtr, string>> callbackProcess)
+		{
+			currentFunctions.EnumerateProcesses(callbackProcess);
+		}
+
+		public void EnumerateRemoteSectionsAndModules(IntPtr process, Action<Section> callbackSection, Action<Module> callbackModule)
+		{
+			currentFunctions.EnumerateRemoteSectionsAndModules(process, callbackSection, callbackModule);
+		}
+
+		public IntPtr OpenRemoteProcess(IntPtr pid, ProcessAccess desiredAccess)
+		{
+			return currentFunctions.OpenRemoteProcess(pid, desiredAccess);
+		}
+
+		public bool IsProcessValid(IntPtr process)
+		{
+			return currentFunctions.IsProcessValid(process);
+		}
+
+		public void CloseRemoteProcess(IntPtr process)
+		{
+			currentFunctions.CloseRemoteProcess(process);
+		}
+
+		public bool ReadRemoteMemory(IntPtr process, IntPtr address, ref byte[] buffer, int offset, int size)
+		{
+			return currentFunctions.ReadRemoteMemory(process, address, ref buffer, offset, size);
+		}
+
+		public bool WriteRemoteMemory(IntPtr process, IntPtr address, ref byte[] buffer, int offset, int size)
+		{
+			return currentFunctions.WriteRemoteMemory(process, address, ref buffer, offset, size);
+		}
+
+		public void ControlRemoteProcess(IntPtr process, ControlRemoteProcessAction action)
+		{
+			currentFunctions.ControlRemoteProcess(process, action);
+		}
+
+		public bool AttachDebuggerToProcess(IntPtr id)
+		{
+			return currentFunctions.AttachDebuggerToProcess(id);
+		}
+
+		public void DetachDebuggerFromProcess(IntPtr id)
+		{
+			currentFunctions.DetachDebuggerFromProcess(id);
+		}
+
+		public void HandleDebugEvent(ref DebugEvent evt)
+		{
+			currentFunctions.HandleDebugEvent(ref evt);
+		}
+
+		public bool AwaitDebugEvent(ref DebugEvent evt, int timeoutInMilliseconds)
+		{
+			return currentFunctions.AwaitDebugEvent(ref evt, timeoutInMilliseconds);
+		}
+
+		public bool SetHardwareBreakpoint(IntPtr id, IntPtr address, HardwareBreakpointRegister register, HardwareBreakpointTrigger trigger, HardwareBreakpointSize size, bool set)
+		{
+			return currentFunctions.SetHardwareBreakpoint(id, address, register, trigger, size, set);
+		}
+
+		#endregion
+
+		#region Internal Core Functions
+
+		public bool DisassembleCode(IntPtr address, int length, IntPtr virtualAddress, out InstructionData instruction)
+		{
+			return internalCoreFunctions.DisassembleCode(address, length, virtualAddress, out instruction);
+		}
+
+		#endregion
+	}
+}

Core/DataExchange.cs

@@ -0,0 +1,30 @@
+using System.Runtime.InteropServices;
+
+namespace ReClassNET.Core
+{
+	public enum ProcessAccess
+	{
+		Read,
+		Write,
+		Full
+	};
+
+	public enum ControlRemoteProcessAction
+	{
+		Suspend,
+		Resume,
+		Terminate
+	}
+
+	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
+	public struct InstructionData
+	{
+		public int Length;
+
+		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 15)]
+		public byte[] Data;
+
+		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
+		public string Instruction;
+	};
+}

Core/ICoreProcessFunctions.cs

@@ -0,0 +1,36 @@
+using System;
+using ReClassNET.Debugger;
+using ReClassNET.Memory;
+using ReClassNET.Native;
+
+namespace ReClassNET.Core
+{
+	public interface ICoreProcessFunctions
+	{
+		void EnumerateProcesses(Action<Tuple<IntPtr, string>> callbackProcess);
+
+		void EnumerateRemoteSectionsAndModules(IntPtr process, Action<Section> callbackSection, Action<Module> callbackModule);
+
+		IntPtr OpenRemoteProcess(IntPtr pid, ProcessAccess desiredAccess);
+
+		bool IsProcessValid(IntPtr process);
+
+		void CloseRemoteProcess(IntPtr process);
+
+		bool ReadRemoteMemory(IntPtr process, IntPtr address, ref byte[] buffer, int offset, int size);
+
+		bool WriteRemoteMemory(IntPtr process, IntPtr address, ref byte[] buffer, int offset, int size);
+
+		void ControlRemoteProcess(IntPtr process, ControlRemoteProcessAction action);
+
+		bool AttachDebuggerToProcess(IntPtr id);
+
+		void DetachDebuggerFromProcess(IntPtr id);
+
+		bool AwaitDebugEvent(ref DebugEvent evt, int timeoutInMilliseconds);
+
+		void HandleDebugEvent(ref DebugEvent evt);
+
+		bool SetHardwareBreakpoint(IntPtr id, IntPtr address, HardwareBreakpointRegister register, HardwareBreakpointTrigger trigger, HardwareBreakpointSize size, bool set);
+	}
+}

Core/InternalCoreFunctions.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Runtime.InteropServices;
+using ReClassNET.Native;
+
+namespace ReClassNET.Core
+{
+	internal class InternalCoreFunctions : NativeCoreWrapper
+	{
+		[return: MarshalAs(UnmanagedType.I1)]
+		private delegate bool DisassembleCodeDelegate(IntPtr address, IntPtr length, IntPtr virtualAddress, out InstructionData instruction);
+
+		private DisassembleCodeDelegate disassembleCodeDelegate;
+
+		public InternalCoreFunctions(IntPtr handle)
+			: base(handle)
+		{
+			disassembleCodeDelegate = GetFunctionDelegate<DisassembleCodeDelegate>(handle, "DisassembleCode");
+		}
+
+		public bool DisassembleCode(IntPtr address, int length, IntPtr virtualAddress, out InstructionData instruction)
+		{
+			return disassembleCodeDelegate(address, (IntPtr)length, virtualAddress, out instruction);
+		}
+	}
+}