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

  ViewVC Help
Powered by ViewVC 1.1.22