RomCheater/Docking/FloatingRamDumperDialog.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using WeifenLuo.WinFormsUI.Docking;
using RomCheater.PluginFramework.Interfaces;
using System.Diagnostics;

namespace RomCheater.Docking
{
    public partial class FloatingRamDumperDialog : DockContent, IProcessConfig
    {
        #region sub-classes
        private const int BYTE_CORRECTION_VALUE = 23;
        public enum DumpSize
        {
            Bytes,
            KiloBytes,
            MegaBytes,
            GigaBytes,
        }
        #endregion
        private DumpSize dumpSize = DumpSize.Bytes;

        public FloatingRamDumperDialog() { InitializeComponent(); this.AcceptedPlugin = null; this.AcceptedProcess = null; }
        public FloatingRamDumperDialog(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
        public FloatingRamDumperDialog(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }
       
        private void FloatingRamDumperDialog_Load(object sender, EventArgs e)
        {
            txtStart.Value = 0;
            txtEnd.Value = int.MaxValue;
        }


        #region IProcessConfig Members'
        public Process AcceptedProcess { get; set; }
        #endregion
        #region IAcceptsPlugin<IConfigPlugin> Members
        public IConfigPlugin AcceptedPlugin { get; set; }
        #endregion

        private void radioBTNBytes_CheckedChanged(object sender, EventArgs e)
        {
            dumpSize = DumpSize.Bytes;
        }

        private void radioBTNKiloBytes_CheckedChanged(object sender, EventArgs e)
        {
            dumpSize = DumpSize.KiloBytes;
        }

        private void radioBTNMegaBytes_CheckedChanged(object sender, EventArgs e)
        {
            dumpSize = DumpSize.MegaBytes;
        }

        private void radioBTNGigaBytes_CheckedChanged(object sender, EventArgs e)
        {
            dumpSize = DumpSize.GigaBytes;
        }

        private void btnCalcEndAddr_Click(object sender, EventArgs e)
        {
            ulong start = 0;
            ulong end = 0;
            start = txtStart.Value;
            switch (dumpSize)
            {
                case DumpSize.Bytes:
                    end = (ulong)(Convert.ToDouble(txtDumpSize.Text) * 1.0 + start) - BYTE_CORRECTION_VALUE;
                    txtEnd.Value = end;
                    break;
                case DumpSize.KiloBytes:
                    end = (ulong)(Convert.ToDouble(txtDumpSize.Text) * 1000.0 + start) - BYTE_CORRECTION_VALUE;
                    txtEnd.Value = end;
                    break;
                case DumpSize.MegaBytes:
                    end = (ulong)(Convert.ToDouble(txtDumpSize.Text) * 1000000.0 + start) - BYTE_CORRECTION_VALUE;
                    txtEnd.Value = end;
                    break;
                case DumpSize.GigaBytes:
                    end = (ulong)(Convert.ToDouble(txtDumpSize.Text) * 1000000000.0 + start) - BYTE_CORRECTION_VALUE;
                    txtEnd.Value = end;
                    break;
            }
        }

        private void btnCalcStartAddr_Click(object sender, EventArgs e)
        {
            long start = 0;
            long end = 0;
            end = txtEnd.ToInt64();
            switch (dumpSize)
            {
                case DumpSize.Bytes:
                    start = (long)((double)end - (Convert.ToDouble(txtDumpSize.Text) * 1.0)) + BYTE_CORRECTION_VALUE;
                    txtStart.Value = (ulong)start;;
                    break;
                case DumpSize.KiloBytes:
                    start = (long)((double)end - (Convert.ToDouble(txtDumpSize.Text) * 1000.0)) + BYTE_CORRECTION_VALUE;
                    txtStart.Value = (ulong)start;;
                    break;
                case DumpSize.MegaBytes:
                    start = (long)((double)end - (Convert.ToDouble(txtDumpSize.Text) * 1000000.0)) + BYTE_CORRECTION_VALUE;
                    txtStart.Value = (ulong)start;;
                    break;
                case DumpSize.GigaBytes:
                    start = (long)((double)end - (Convert.ToDouble(txtDumpSize.Text) * 1000000000.0)) + BYTE_CORRECTION_VALUE;
                    txtStart.Value = (ulong)start;
                    break;
            }
        }

        private void btnCalcDumpSize_Click(object sender, EventArgs e)
        {
            ulong start = txtStart.Value;
            ulong end = txtEnd.Value;
            ulong byte_diff = (end - start) + BYTE_CORRECTION_VALUE;
            switch (dumpSize)
            {
                case DumpSize.Bytes:
                    txtDumpSize.Text = string.Format("{0:n2}", (double)byte_diff);
                    break;
                case DumpSize.KiloBytes:
                    txtDumpSize.Text = string.Format("{0:n3}", (double)byte_diff / 1000.0);
                    break;
                case DumpSize.MegaBytes:
                    txtDumpSize.Text = string.Format("{0:n6}", (double)byte_diff / 1000000.0);
                    break;
                case DumpSize.GigaBytes:
                    txtDumpSize.Text = string.Format("{0:n9}", (double)byte_diff / 1000000000.0);
                    break;
            }
        }

        private void btnDumpRam_Click(object sender, EventArgs e)
        {
            if (this.AcceptedProcess == null)
            {
                MessageBox.Show("Please select a process to dump memory from", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
            DialogResult result = dumpsaver.ShowDialog();
            if (result != DialogResult.OK) return;
            DumpRam(txtStart.Value, txtEnd.Value, dumpsaver.FileName);
        }


        #region memory support
        private void DumpRam(ulong start, ulong end, string filename)
        {
            uint byte_count = (uint)(end - start);
            DumpRam(start, byte_count, filename);
        }
        private void DumpRam(ulong start, uint count, string filename)
        {
            if (this.AcceptedProcess == null) return;
            Sojaner.MemoryScanner.ProcessMemoryReader reader = new Sojaner.MemoryScanner.ProcessMemoryReader();
            reader.ReadProcess = this.AcceptedProcess;
            reader.OpenProcess();
            int bytesReadSize;
            byte[] data = reader.ReadProcessMemory((IntPtr)(uint)start, count, out bytesReadSize);
            reader.CloseHandle();
        }
        #endregion
    }
}
Revision:	156
Committed:	Mon May 28 04:14:03 2012 UTC (11 years, 6 months ago) by william
File size:	6774 byte(s)
Log Message:	+ add support for selecting process by different means
#	Content
1	using System;
2	using System.Collections.Generic;
3	using System.ComponentModel;
4	using System.Data;
5	using System.Drawing;
6	using System.Linq;
7	using System.Text;
8	using System.Windows.Forms;
9	using WeifenLuo.WinFormsUI.Docking;
10	using RomCheater.PluginFramework.Interfaces;
11	using System.Diagnostics;
12
13	namespace RomCheater.Docking
14	{
15	public partial class FloatingRamDumperDialog : DockContent, IProcessConfig
16	{
17	#region sub-classes
18	private const int BYTE_CORRECTION_VALUE = 23;
19	public enum DumpSize
20	{
21	Bytes,
22	KiloBytes,
23	MegaBytes,
24	GigaBytes,
25	}
26	#endregion
27	private DumpSize dumpSize = DumpSize.Bytes;
28
29	public FloatingRamDumperDialog() { InitializeComponent(); this.AcceptedPlugin = null; this.AcceptedProcess = null; }
30	public FloatingRamDumperDialog(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
31	public FloatingRamDumperDialog(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }
32
33	private void FloatingRamDumperDialog_Load(object sender, EventArgs e)
34	{
35	txtStart.Value = 0;
36	txtEnd.Value = int.MaxValue;
37	}
38
39
40	#region IProcessConfig Members'
41	public Process AcceptedProcess { get; set; }
42	#endregion
43	#region IAcceptsPlugin<IConfigPlugin> Members
44	public IConfigPlugin AcceptedPlugin { get; set; }
45	#endregion
46
47	private void radioBTNBytes_CheckedChanged(object sender, EventArgs e)
48	{
49	dumpSize = DumpSize.Bytes;
50	}
51
52	private void radioBTNKiloBytes_CheckedChanged(object sender, EventArgs e)
53	{
54	dumpSize = DumpSize.KiloBytes;
55	}
56
57	private void radioBTNMegaBytes_CheckedChanged(object sender, EventArgs e)
58	{
59	dumpSize = DumpSize.MegaBytes;
60	}
61
62	private void radioBTNGigaBytes_CheckedChanged(object sender, EventArgs e)
63	{
64	dumpSize = DumpSize.GigaBytes;
65	}
66
67	private void btnCalcEndAddr_Click(object sender, EventArgs e)
68	{
69	ulong start = 0;
70	ulong end = 0;
71	start = txtStart.Value;
72	switch (dumpSize)
73	{
74	case DumpSize.Bytes:
75	end = (ulong)(Convert.ToDouble(txtDumpSize.Text) * 1.0 + start) - BYTE_CORRECTION_VALUE;
76	txtEnd.Value = end;
77	break;
78	case DumpSize.KiloBytes:
79	end = (ulong)(Convert.ToDouble(txtDumpSize.Text) * 1000.0 + start) - BYTE_CORRECTION_VALUE;
80	txtEnd.Value = end;
81	break;
82	case DumpSize.MegaBytes:
83	end = (ulong)(Convert.ToDouble(txtDumpSize.Text) * 1000000.0 + start) - BYTE_CORRECTION_VALUE;
84	txtEnd.Value = end;
85	break;
86	case DumpSize.GigaBytes:
87	end = (ulong)(Convert.ToDouble(txtDumpSize.Text) * 1000000000.0 + start) - BYTE_CORRECTION_VALUE;
88	txtEnd.Value = end;
89	break;
90	}
91	}
92
93	private void btnCalcStartAddr_Click(object sender, EventArgs e)
94	{
95	long start = 0;
96	long end = 0;
97	end = txtEnd.ToInt64();
98	switch (dumpSize)
99	{
100	case DumpSize.Bytes:
101	start = (long)((double)end - (Convert.ToDouble(txtDumpSize.Text) * 1.0)) + BYTE_CORRECTION_VALUE;
102	txtStart.Value = (ulong)start;;
103	break;
104	case DumpSize.KiloBytes:
105	start = (long)((double)end - (Convert.ToDouble(txtDumpSize.Text) * 1000.0)) + BYTE_CORRECTION_VALUE;
106	txtStart.Value = (ulong)start;;
107	break;
108	case DumpSize.MegaBytes:
109	start = (long)((double)end - (Convert.ToDouble(txtDumpSize.Text) * 1000000.0)) + BYTE_CORRECTION_VALUE;
110	txtStart.Value = (ulong)start;;
111	break;
112	case DumpSize.GigaBytes:
113	start = (long)((double)end - (Convert.ToDouble(txtDumpSize.Text) * 1000000000.0)) + BYTE_CORRECTION_VALUE;
114	txtStart.Value = (ulong)start;
115	break;
116	}
117	}
118
119	private void btnCalcDumpSize_Click(object sender, EventArgs e)
120	{
121	ulong start = txtStart.Value;
122	ulong end = txtEnd.Value;
123	ulong byte_diff = (end - start) + BYTE_CORRECTION_VALUE;
124	switch (dumpSize)
125	{
126	case DumpSize.Bytes:
127	txtDumpSize.Text = string.Format("{0:n2}", (double)byte_diff);
128	break;
129	case DumpSize.KiloBytes:
130	txtDumpSize.Text = string.Format("{0:n3}", (double)byte_diff / 1000.0);
131	break;
132	case DumpSize.MegaBytes:
133	txtDumpSize.Text = string.Format("{0:n6}", (double)byte_diff / 1000000.0);
134	break;
135	case DumpSize.GigaBytes:
136	txtDumpSize.Text = string.Format("{0:n9}", (double)byte_diff / 1000000000.0);
137	break;
138	}
139	}
140
141	private void btnDumpRam_Click(object sender, EventArgs e)
142	{
143	if (this.AcceptedProcess == null)
144	{
145	MessageBox.Show("Please select a process to dump memory from", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
146	return;
147	}
148	DialogResult result = dumpsaver.ShowDialog();
149	if (result != DialogResult.OK) return;
150	DumpRam(txtStart.Value, txtEnd.Value, dumpsaver.FileName);
151	}
152
153
154	#region memory support
155	private void DumpRam(ulong start, ulong end, string filename)
156	{
157	uint byte_count = (uint)(end - start);
158	DumpRam(start, byte_count, filename);
159	}
160	private void DumpRam(ulong start, uint count, string filename)
161	{
162	if (this.AcceptedProcess == null) return;
163	Sojaner.MemoryScanner.ProcessMemoryReader reader = new Sojaner.MemoryScanner.ProcessMemoryReader();
164	reader.ReadProcess = this.AcceptedProcess;
165	reader.OpenProcess();
166	int bytesReadSize;
167	byte[] data = reader.ReadProcessMemory((IntPtr)(uint)start, count, out bytesReadSize);
168	reader.CloseHandle();
169	}
170	#endregion
171	}
172	}