ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/RomCheater/trunk/RomCheater.CorePlugins/Config/PCSX2Config.cs
(Generate patch)

Comparing trunk/RomCheater.CorePlugins/Config/PCSX2Config.cs (file contents):
Revision 147 by william, Sun May 27 23:05:18 2012 UTC vs.
Revision 389 by william, Tue Jun 19 12:47:26 2012 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines