public async Task Constructor_PortPartnerPort_PassesMessages() { i1 = new IpcInterface(13773, 13774); i2 = new IpcInterface(i1.PartnerPort, i1.Port); await SpinlockForMessage(); }
/// <summary> /// This callback is invoked whenever this process calls CreateFile(). This is where we can modify parameters and other cool things. /// </summary> /// <remarks> /// The method signature must match the original CreateFile(). /// </remarks> private IntPtr OnCreateFile(string filePath, uint desiredAccess, uint shareMode, IntPtr securityAttributes, uint creationDisposition, uint flags, IntPtr templateFile) { try { /* * Note that we can do whatever we want in this callback. We could change the file path, return an access denied (pretend we're an antivirus program), * but we won't do that in this program. This program only monitors file access from processes. */ var fileEntry = new FileEntry() { FullPath = filePath, Timestamp = DateTime.Now }; var processId = Process.GetCurrentProcess().Id; IpcInterface.AddFileEntry(processId, fileEntry); } catch (Exception ex) { IpcInterface.PostException(ex); } // The process had originally intended to call CreateFile(), so let's actually call Windows' original CreateFile() return(CreateFile(filePath, desiredAccess, shareMode, securityAttributes, creationDisposition, flags, templateFile)); }
public static async Task MainAsync(string[] args) { var i2 = new IpcInterface(int.Parse(args[0]), int.Parse(args[1])); await i2.SendMessage(new DummyClass()); await Task.Delay(-1); }
public async Task ReceiveMessage_AvgTimeIsBelow1Ms() { i1 = new IpcInterface(); i2 = new IpcInterface(i1.PartnerPort, i1.Port); var dummyClass = new DummyClass(); var stopwatch = new Stopwatch(); var spinLock = true; i1.On <DummyClass>(dc => { stopwatch.Stop(); spinLock = false; }); for (var i = 0; i < Iterations; i++) { await i2.SendMessage(dummyClass); stopwatch.Start(); while (spinLock) { await Task.Delay(1); } spinLock = true; } var averageMs = stopwatch.ElapsedMilliseconds / Iterations; Assert.IsTrue(averageMs <= 1, "Expected <=1ms, got {0}ms", averageMs); }
public async Task Constructor_HttpClientPortPartnerPort_PassesMessages() { using var http = new HttpClient(); i1 = new IpcInterface(http, 13773, 13774); i2 = new IpcInterface(i1.PartnerPort, i1.Port); await SpinlockForMessage(); }
public void SendFileList(params string[] files) { var ipc = new IpcInterface(); foreach (string file in files) { ipc.AddInputFile(file); } ipc.UpdateUI(); }
/// <summary> /// When accepted client tries to make connection. /// </summary> /// <param name="pipe">the pipe</param> /// <param name="status">status of connect</param> /// <remarks>hen this function calls, it is right before making connection, /// so user can configure the pipe before the connection is actually made. </remarks> public void OnNewConnection(IpcInterface pipe, IpcConnectStatus status) { if (status == IpcConnectStatus.SUCCESS) { if (!m_pipes.Contains(pipe)) { m_pipes.Add(pipe); } } m_options.m_callBackObj.OnNewConnection(this, pipe, status); }
public FormMain() { InitializeComponent(); // Prevent ListView flickering ListViewHelper.EnableDoubleBuffer(ListViewLog); ListViewHelper.EnableDoubleBuffer(ListViewProcesses); IpcInterface = new IpcInterface(); IpcInterface.OnMessagePosted += IpcInterface_OnMessagePosted; ProcessEntries = new List <ProcessEntry>(); }
public void Unload() { try { // We're exiting our program now IpcInterface.TerminatingProcesses.Remove(Process.GetCurrentProcess().Id); CreateFileHook.Dispose(); } catch (Exception ex) { IpcInterface.PostException(ex); } }
public async Task SendMessage_WorksWithActualChildProcess() { i1 = new IpcInterface(); var spinLock = true; i1.On <DummyClass>(dummyClass => { spinLock = false; }); var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "..", "..", "..", "..", "SimpleIPCHttp.TestDummy", "bin", "Debug", "netcoreapp3.1", "SimpleIPCHttp.TestDummy.exe"); var program = Process.Start(path, $"{i1.PartnerPort} {i1.Port}"); while (spinLock) { await Task.Delay(SpinlockWait); } program.Kill(); }
/// <summary> /// The pipe is disconnected. /// </summary> /// <param name="pipe">the pipe, disconnected.</param> public void OnDisconnected(IpcInterface pipe) { lock (m_pipes) { if (m_pipes.Contains(pipe)) { m_pipes.Remove(pipe); } if (m_started) { pipe.Reconnect(); } } m_options.m_callBackObj.OnDisconnected(this, pipe); }
public async Task On_FiresOnCorrectTypeOnly() { i1 = new IpcInterface(); i2 = new IpcInterface(i1.PartnerPort, i1.Port); var spinLock = true; i1.On <DummyClass>(dummyClass => { spinLock = false; }); i1.On <DummierClass>(dummierClass => {}); await i2.SendMessage(new DummierClass()); await Task.Delay(SpinlockWait * 5000); Assert.IsTrue(spinLock); }
public void Load() { try { CreateFileHook = LocalHook.Create( LocalHook.GetProcAddress("kernel32.dll", "CreateFileW"), new CreateFileDelegate(OnCreateFile), this); // All hooks start de-activated // The following ensures that this hook can be intercepted from all threads of this process CreateFileHook.ThreadACL.SetExclusiveACL(new Int32[1]); } catch (Exception ex) { IpcInterface.PostException(ex); } }
private void ButtonInject_CheckedChanged(object sender, System.EventArgs e) { if (this.ButtonInject.IsDepressed) { try { var processName = this.TextBoxProcess.Text; var processes = Process.GetProcessesByName(processName); if (processes.Any()) { this.IpcInterface = new IpcInterface(); if (CheckStartPaused.Checked) { IpcInterface.StartPaused = true; } InjectionHelper.IpcServerCreateListeningChannel(this.IpcInterface); EasyHook.Config.Register("Starcraft 2 AI Bot", "Logging.dll", "RemotingInterface.dll", "Interceptor.dll", "Game.dll", "Direct3D9Hook.dll", "NLog.dll", "SharpDX.dll", "SharpDX.Direct3D9.dll"); InjectionHelper.Inject("Interceptor.dll", "Interceptor.dll", processes.First().Id); } } catch (Exception ex) { MessageBox.Show(ex.ToString(), "Injection Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } } else { // Should exit, but not implemented } }
public void Main() { try { // All of our program's main execution takes place within the OnCreateFile() hook callback. So we don't really do anything here. // Except Ping() our FileMonitorController program to make sure it's still alive; if it's closed, we should also close while (!IpcInterface.TerminatingProcesses.Contains(Process.GetCurrentProcess().Id)) { Thread.Sleep(0); IpcInterface.Ping(); } // When this method returns (and, consequently, Run()), our injected DLL terminates and that's the end of our program (though Unload() will be called first) } catch (Exception ex) { IpcInterface.PostException(ex); } }
public async Task SendMessage_AvgTimeIsBelow1Ms() { i1 = new IpcInterface(); i2 = new IpcInterface(i1.PartnerPort, i1.Port); var stopwatch = new Stopwatch(); i1.On <DummyClass>(dummyClass => {}); for (var i = 0; i < Iterations; i++) { stopwatch.Start(); await i2.SendMessage(new DummyClass()); stopwatch.Stop(); } var averageMs = stopwatch.ElapsedMilliseconds / Iterations; Assert.IsTrue(averageMs <= 1, "Expected <=1ms, got {0}ms", averageMs); }
public MogmogInteropConnectionManager(MogmogConfiguration config, HttpClient client) { this.client = client; this.ipc = new IpcInterface(client); this.ipc.On <ChatMessageInterop>(ChatMessageReceived); this.ipc.On <GenericInterop>(LogMessageReceived); var filePath = Path.Combine(Assembly.GetExecutingAssembly().Location, "..", "Mogmog.FFXIV.UpgradeLayer.exe"); var serializedConfig = JsonConvert.SerializeObject(config).Replace("\"", "\\\""); var args = $"{serializedConfig} {this.ipc.PartnerPort} {this.ipc.Port}"; var startInfo = new ProcessStartInfo(filePath, string.Join(" ", args)) { CreateNoWindow = true, UseShellExecute = false, WindowStyle = ProcessWindowStyle.Hidden, }; this.upgradeLayer = Process.Start(startInfo); }
public static void IpcServerCreateListeningChannel(IpcInterface ipcInterface) { ipcServer = RemoteHooking.IpcCreateServer <IpcInterface>(ref IpcChannelName, WellKnownObjectMode.Singleton, ipcInterface, IpcChannelName, true, WellKnownSidType.WorldSid); }
public virtual void CreateSocket(byte _0, out uint _1, out IpcInterface _2) => throw new NotImplementedException();
public virtual void Accept(out byte[] _0, out uint _1, out IpcInterface _2) => throw new NotImplementedException();
/// <summary> /// When accepted client tries to make connection. /// </summary> /// <param name="pipe">the pipe</param> /// <param name="status">status of connect</param> /// <remarks>hen this function calls, it is right before making connection, /// so user can configure the pipe before the connection is actually made. </remarks> public void OnNewConnection(IpcInterface pipe, IpcConnectStatus status) { if (status == IpcConnectStatus.SUCCESS) { if (!m_pipes.Contains(pipe)) m_pipes.Add(pipe); } m_options.m_callBackObj.OnNewConnection(this, pipe, status); }
/// <summary> /// Received the data from the client. /// </summary> /// <param name="pipe">the pipe which received the packet</param> /// <param name="receivedData">the received data</param> /// <param name="receivedDataByteSize">the received data byte size</param> public void OnReadComplete(IpcInterface pipe, byte[] receivedData, int receivedDataByteSize) { m_options.m_callBackObj.OnReadComplete(this, pipe, receivedData, receivedDataByteSize); }
/// <summary> /// Received the packet from the client. /// </summary> /// <param name="pipe">the pipe which wrote the packet</param> /// <param name="status">the status of write</param> public void OnWriteComplete(IpcInterface pipe, IpcWriteStatus status) { m_options.m_callBackObj.OnWriteComplete(this, pipe, status); }
/// <summary> /// The pipe is disconnected. /// </summary> /// <param name="pipe">the pipe, disconnected.</param> public void OnDisconnected(IpcInterface pipe) { lock (m_pipes) { if (m_pipes.Contains(pipe)) m_pipes.Remove(pipe); if(m_started) pipe.Reconnect(); } m_options.m_callBackObj.OnDisconnected(this, pipe); }
public void Constructor_Default_PortsAreConsistent() { i1 = new IpcInterface(); i2 = new IpcInterface(i1.PartnerPort, i1.Port); Assert.IsTrue(i1.Port == i2.PartnerPort && i1.PartnerPort == i2.Port, "Got i1: [{0} {1}] i2: [{2} {3}], expected i1: [{0} {1}] i2: [{0} {1}]", i1.Port, i1.PartnerPort, i2.Port, i2.PartnerPort); }
public virtual void CreateSocketOld(out uint _0, out IpcInterface _1) => throw new NotImplementedException();
static IpcInterface RemoveDuplicates(IpcInterface iface) =>