RomCheater.CorePlugins/Config/PCSX2Config.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using RomCheater.PluginFramework.Core;
using System.IO;
using System.Diagnostics;
using RomCheater.Logging;

namespace RomCheater.CorePlugins.Config
{
    public sealed class PCSX2Config : ConfigPlugin
    {
        #region Configuration Memvers
        const string PCXS2_PROCESS_MAGIC = "pcsx2";
        const string PCXS2_LOOKUP_MAGIC_001 = "pcsx2";
        const string PCXS2_LOOKUP_MAGIC_002 = "compiled on";

        const uint VTLB_VADDR_OFFSET_DEBUG = 0x20000000;
        #endregion

        public PCSX2Config() : base(false) { }
        public PCSX2Config(bool doinit) : base(doinit) { }


        protected override bool IsNotValidProcess(ProcContainer p)
        {
            bool isDebug = false;
            uint VTLB_RELEASE_OFFSET = 0;
            bool notvalid = !IsValidPSX2Process(p.ProcessInfo.Id, out isDebug, out VTLB_RELEASE_OFFSET);
            if (notvalid)
            {
                logger.VerboseDebug.WriteLine("    Not Allowing process {0} to be added because it was filterd out", p.Name);
            }
            else
            {
                logger.VerboseDebug.WriteLine("    Allowing process {0} to be added", p.Name);
            }
            return notvalid;
        }
        #region IPluginBase Members
        public override Guid ID
        {
            get
            {
                return new GuidGenerator(typeof(PCSX2Config).FullName).Guid;
            }
        }
        public override string Name
        {
            get { return "PCSX2 Configuration Plugin"; }
        }
        public override string Description
        {
            get { return "This plugin provides a configuration suitable for use with PCSX2"; }
        }
        #endregion

        private static bool IsValidPSX2Process(int pid, out bool isDebug, out uint VTLB_RELEASE_OFFSET)
        {
            bool isValid = false;
            isDebug = false;
            VTLB_RELEASE_OFFSET = 0;
            try
            {
                Process p = Process.GetProcessById(pid);
                string filename = p.MainModule.FileName;

                FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read);
                BinaryReader r = new BinaryReader(fs);
                byte[] exe_check = new byte[] {
                0x4D, 0x5A, 0x90, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 
                0xB8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 
                0x0E, 0x1F, 0xBA, 0x0E, 0x00, 0xB4, 0x09, 0xCD, 0x21, 0xB8, 0x01, 0x4C, 0xCD, 0x21, 0x54, 0x68, 
                0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x67, 0x72, 0x61, 0x6D, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F,
                0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x69, 0x6E, 0x20, 0x44, 0x4F, 0x53, 0x20, 
                0x6D, 0x6F, 0x64, 0x65, 0x2E
                };

                r.BaseStream.Seek(0, SeekOrigin.Begin);
                byte[] data = r.ReadBytes(exe_check.Length);
                bool isExe = false;
                for (int i = 0; i < exe_check.Length; i++) { if (exe_check[i] == data[i]) { isExe = true; } else { isExe = false; } }
                r.Close();
                if (!isExe)
                {
                    logger.VerboseDebug.WriteLine("  Process: {0} is not a valid executable file", filename);
                    isValid = false;
                }
                else
                {
                    // check for valid pcsx2 exe
                    fs = new FileStream(filename, FileMode.Open, FileAccess.Read);
                    StreamReader sr = new StreamReader(fs);
                    string found_string = sr.ReadToEnd();
                    if (found_string.ToLower().Contains(PCXS2_LOOKUP_MAGIC_001.ToLower()) && found_string.ToLower().Contains(PCXS2_LOOKUP_MAGIC_002.ToLower()))
                    {
                        isValid = true;
                        logger.VerboseDebug.WriteLine("  Process: {0} found MAGIC LOOKUP {1} and {2}", filename, PCXS2_LOOKUP_MAGIC_001.ToLower(), PCXS2_LOOKUP_MAGIC_002.ToLower());
                    }
                    sr.Close();

                    // check for debug               
                    fs = new FileStream(filename, FileMode.Open, FileAccess.Read);
                    sr = new StreamReader(fs);
                    found_string = sr.ReadToEnd();
                    // DebugBreak should only be present in debug build version(s) of pcsx2
                    if (found_string.ToLower().Contains("DebugBreak".ToLower()))
                    {
                        isDebug = true;
                        logger.VerboseDebug.WriteLine("  Process: {0} found DebugBreak", filename);
                    }
                    sr.Close();
                }
                //this.IsDebugBuild = isDebug;

                // run check to see if we have a later version with offset fixed at: 0x20000000


                byte[] entrypoint_data = new byte[]{
                        0x01, 0x80, 0x1A, 0x3C, 0x78, 0x53, 0x59, 0xFF, 0x00, 0x68, 0x19, 0x40,
                        0x01, 0x80, 0x1A, 0x3C, 0x7C, 0x00, 0x39, 0x33, 0x21, 0xD0, 0x59, 0x03,
                        0x40, 0x53, 0x5A, 0x8F, 0x01, 0x80, 0x19, 0x3C, 0x08, 0x00, 0x40, 0x03,
                        0x78, 0x53, 0x39, 0xDF
                };

                //uint address = ramdumper.VTLB_VADDR_OFFSET_DEBUG;
                Sojaner.MemoryScanner.ProcessMemoryReader reader = new Sojaner.MemoryScanner.ProcessMemoryReader();
                reader.ReadProcess = p;
                reader.OpenProcess();
                int bytesReadSize;
                byte[] check_data = reader.ReadProcessMemory((IntPtr)VTLB_VADDR_OFFSET_DEBUG, (uint)entrypoint_data.Length, out bytesReadSize);

                isDebug = check_data.SequenceEqual(entrypoint_data);
                logger.Debug.WriteLine("  Process: {0} isDebug: {1}", filename, isDebug.ToString());
                //List<uint> addresses = new List<uint>();
                if (!isDebug)
                {

                    for (int i = 0x1000; i < 0x2000;i++ )
                    {
                        try
                        {
                            uint t = ((uint)i << 16) | 0x5000;
                            check_data = reader.ReadProcessMemory((IntPtr)t, (uint)entrypoint_data.Length, out bytesReadSize);
                            isValid = check_data.SequenceEqual(entrypoint_data);
                            if (isValid)
                            {
                                //addresses.Add(t);
                                VTLB_RELEASE_OFFSET = t;
                                logger.VerboseDebug.WriteLine("  Process: {0} found release build entrypoint at 0x{1:x8}", filename, t);
                                break; //use only the first valid value
                            }
                        }
                        catch { }
                    }
                    
                }
                reader.CloseHandle();
                return isValid;
            }
            catch (System.ComponentModel.Win32Exception) { }
            catch (Exception) { }
            return isValid;
        }
    }
}
Revision:	108
Committed:	Thu May 10 11:31:05 2012 UTC (11 years, 6 months ago) by william
File size:	7712 byte(s)
Log Message:	move debug logging to verbosedebug
#	User	Rev	Content
1	william	92	using System;
2			using System.Collections.Generic;
3			using System.Linq;
4			using System.Text;
5			using RomCheater.PluginFramework.Core;
6			using System.IO;
7			using System.Diagnostics;
8	william	98	using RomCheater.Logging;
9	william	92
10			namespace RomCheater.CorePlugins.Config
11			{
12			public sealed class PCSX2Config : ConfigPlugin
13			{
14			#region Configuration Memvers
15			const string PCXS2_PROCESS_MAGIC = "pcsx2";
16			const string PCXS2_LOOKUP_MAGIC_001 = "pcsx2";
17			const string PCXS2_LOOKUP_MAGIC_002 = "compiled on";
18
19			const uint VTLB_VADDR_OFFSET_DEBUG = 0x20000000;
20			#endregion
21
22			public PCSX2Config() : base(false) { }
23			public PCSX2Config(bool doinit) : base(doinit) { }
24
25
26			protected override bool IsNotValidProcess(ProcContainer p)
27			{
28			bool isDebug = false;
29			uint VTLB_RELEASE_OFFSET = 0;
30	william	98	bool notvalid = !IsValidPSX2Process(p.ProcessInfo.Id, out isDebug, out VTLB_RELEASE_OFFSET);
31			if (notvalid)
32			{
33	william	108	logger.VerboseDebug.WriteLine(" Not Allowing process {0} to be added because it was filterd out", p.Name);
34	william	98	}
35			else
36			{
37	william	108	logger.VerboseDebug.WriteLine(" Allowing process {0} to be added", p.Name);
38	william	98	}
39			return notvalid;
40	william	92	}
41			#region IPluginBase Members
42	william	94	public override Guid ID
43	william	92	{
44			get
45			{
46			return new GuidGenerator(typeof(PCSX2Config).FullName).Guid;
47			}
48			}
49			public override string Name
50			{
51			get { return "PCSX2 Configuration Plugin"; }
52			}
53			public override string Description
54			{
55			get { return "This plugin provides a configuration suitable for use with PCSX2"; }
56			}
57			#endregion
58
59			private static bool IsValidPSX2Process(int pid, out bool isDebug, out uint VTLB_RELEASE_OFFSET)
60			{
61			bool isValid = false;
62			isDebug = false;
63			VTLB_RELEASE_OFFSET = 0;
64			try
65			{
66			Process p = Process.GetProcessById(pid);
67			string filename = p.MainModule.FileName;
68
69			FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read);
70			BinaryReader r = new BinaryReader(fs);
71			byte[] exe_check = new byte[] {
72			0x4D, 0x5A, 0x90, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00,
73			0xB8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
74			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
75			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
76			0x0E, 0x1F, 0xBA, 0x0E, 0x00, 0xB4, 0x09, 0xCD, 0x21, 0xB8, 0x01, 0x4C, 0xCD, 0x21, 0x54, 0x68,
77			0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x67, 0x72, 0x61, 0x6D, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F,
78			0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x69, 0x6E, 0x20, 0x44, 0x4F, 0x53, 0x20,
79			0x6D, 0x6F, 0x64, 0x65, 0x2E
80			};
81
82			r.BaseStream.Seek(0, SeekOrigin.Begin);
83			byte[] data = r.ReadBytes(exe_check.Length);
84			bool isExe = false;
85			for (int i = 0; i < exe_check.Length; i++) { if (exe_check[i] == data[i]) { isExe = true; } else { isExe = false; } }
86			r.Close();
87			if (!isExe)
88			{
89	william	108	logger.VerboseDebug.WriteLine(" Process: {0} is not a valid executable file", filename);
90	william	92	isValid = false;
91			}
92			else
93			{
94			// check for valid pcsx2 exe
95			fs = new FileStream(filename, FileMode.Open, FileAccess.Read);
96			StreamReader sr = new StreamReader(fs);
97			string found_string = sr.ReadToEnd();
98			if (found_string.ToLower().Contains(PCXS2_LOOKUP_MAGIC_001.ToLower()) && found_string.ToLower().Contains(PCXS2_LOOKUP_MAGIC_002.ToLower()))
99			{
100			isValid = true;
101	william	108	logger.VerboseDebug.WriteLine(" Process: {0} found MAGIC LOOKUP {1} and {2}", filename, PCXS2_LOOKUP_MAGIC_001.ToLower(), PCXS2_LOOKUP_MAGIC_002.ToLower());
102	william	92	}
103			sr.Close();
104
105			// check for debug
106			fs = new FileStream(filename, FileMode.Open, FileAccess.Read);
107			sr = new StreamReader(fs);
108			found_string = sr.ReadToEnd();
109			// DebugBreak should only be present in debug build version(s) of pcsx2
110			if (found_string.ToLower().Contains("DebugBreak".ToLower()))
111			{
112			isDebug = true;
113	william	108	logger.VerboseDebug.WriteLine(" Process: {0} found DebugBreak", filename);
114	william	92	}
115			sr.Close();
116			}
117			//this.IsDebugBuild = isDebug;
118
119			// run check to see if we have a later version with offset fixed at: 0x20000000
120
121
122			byte[] entrypoint_data = new byte[]{
123			0x01, 0x80, 0x1A, 0x3C, 0x78, 0x53, 0x59, 0xFF, 0x00, 0x68, 0x19, 0x40,
124			0x01, 0x80, 0x1A, 0x3C, 0x7C, 0x00, 0x39, 0x33, 0x21, 0xD0, 0x59, 0x03,
125			0x40, 0x53, 0x5A, 0x8F, 0x01, 0x80, 0x19, 0x3C, 0x08, 0x00, 0x40, 0x03,
126			0x78, 0x53, 0x39, 0xDF
127			};
128
129			//uint address = ramdumper.VTLB_VADDR_OFFSET_DEBUG;
130			Sojaner.MemoryScanner.ProcessMemoryReader reader = new Sojaner.MemoryScanner.ProcessMemoryReader();
131			reader.ReadProcess = p;
132			reader.OpenProcess();
133			int bytesReadSize;
134			byte[] check_data = reader.ReadProcessMemory((IntPtr)VTLB_VADDR_OFFSET_DEBUG, (uint)entrypoint_data.Length, out bytesReadSize);
135
136			isDebug = check_data.SequenceEqual(entrypoint_data);
137	william	98	logger.Debug.WriteLine(" Process: {0} isDebug: {1}", filename, isDebug.ToString());
138	william	92	//List<uint> addresses = new List<uint>();
139			if (!isDebug)
140			{
141
142			for (int i = 0x1000; i < 0x2000;i++ )
143			{
144			try
145			{
146			uint t = ((uint)i << 16) \| 0x5000;
147			check_data = reader.ReadProcessMemory((IntPtr)t, (uint)entrypoint_data.Length, out bytesReadSize);
148			isValid = check_data.SequenceEqual(entrypoint_data);
149			if (isValid)
150			{
151			//addresses.Add(t);
152			VTLB_RELEASE_OFFSET = t;
153	william	99	logger.VerboseDebug.WriteLine(" Process: {0} found release build entrypoint at 0x{1:x8}", filename, t);
154	william	92	break; //use only the first valid value
155			}
156			}
157			catch { }
158			}
159
160			}
161			reader.CloseHandle();
162			return isValid;
163			}
164			catch (System.ComponentModel.Win32Exception) { }
165			catch (Exception) { }
166			return isValid;
167			}
168			}
169			}