/[RomCheater]/trunk/RomCheater.CorePlugins/Config/PCSX2Config.cs
ViewVC logotype

Diff of /trunk/RomCheater.CorePlugins/Config/PCSX2Config.cs

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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

Legend:
Removed from v.147  
changed lines
  Added in v.390

  ViewVC Help
Powered by ViewVC 1.1.22