/[RomCheater]/trunk/Win32/Sojaner.MemoryScanner/MemoryProviers/BaseMemoryProvider.cs
ViewVC logotype

Diff of /trunk/Win32/Sojaner.MemoryScanner/MemoryProviers/BaseMemoryProvider.cs

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

revision 254 by william, Sun Jun 3 16:32:58 2012 UTC revision 255 by william, Sun Jun 3 16:45:47 2012 UTC
# Line 11  namespace Sojaner.MemoryScanner.MemoryPr Line 11  namespace Sojaner.MemoryScanner.MemoryPr
11  {  {
12      #region public abstract class BaseMemoryProvider      #region public abstract class BaseMemoryProvider
13      public abstract class BaseMemoryProvider :      public abstract class BaseMemoryProvider :
14          IPatchMemory,          IPatchMemory,
15          IReadMemory,          IReadMemory,
16          IAcceptsProcess<Process>,          IAcceptsProcess<Process>,
17          IAcceptsPlugin<IConfigPlugin>,          IAcceptsPlugin<IConfigPlugin>,
18          IMemoryReader,          IMemoryReader,
# Line 49  namespace Sojaner.MemoryScanner.MemoryPr Line 49  namespace Sojaner.MemoryScanner.MemoryPr
49              }              }
50              catch (Exception ex)              catch (Exception ex)
51              {              {
52                  logger.Error.WriteLine("Failed to open provider: {0}{1}",System.Environment.NewLine, ex.ToString());                  logger.Error.WriteLine("Failed to open provider: {0}{1}", System.Environment.NewLine, ex.ToString());
53                  isOpen = false;                  isOpen = false;
54                  isClosed = true;                  isClosed = true;
55              }              }
# Line 58  namespace Sojaner.MemoryScanner.MemoryPr Line 58  namespace Sojaner.MemoryScanner.MemoryPr
58          #region public virtual void CloseProvider()          #region public virtual void CloseProvider()
59          public virtual void CloseProvider()          public virtual void CloseProvider()
60          {          {
61              if (isClosed)              if (isClosed)
62              {              {
63                  logger.Warn.WriteLine("Provider has already been closed.");                  logger.Warn.WriteLine("Provider has already been closed.");
64                  return;                  return;
# Line 157  namespace Sojaner.MemoryScanner.MemoryPr Line 157  namespace Sojaner.MemoryScanner.MemoryPr
157              int bytesWritten;              int bytesWritten;
158              byte[] bitData = BitConverter.GetBytes(value);              byte[] bitData = BitConverter.GetBytes(value);
159              provider.WriteProcessMemory(address, bitData, out bytesWritten);              provider.WriteProcessMemory(address, bitData, out bytesWritten);
160                
161              ushort check = 0;              ushort check = 0;
162              ReadMemory(address, out check);              ReadMemory(address, out check);
163              if (check == value) return true;              if (check == value) return true;
# Line 171  namespace Sojaner.MemoryScanner.MemoryPr Line 171  namespace Sojaner.MemoryScanner.MemoryPr
171              int bytesWritten;              int bytesWritten;
172              byte[] bitData = BitConverter.GetBytes(value);              byte[] bitData = BitConverter.GetBytes(value);
173              provider.WriteProcessMemory(address, bitData, out bytesWritten);              provider.WriteProcessMemory(address, bitData, out bytesWritten);
174                
175              short check = 0;              short check = 0;
176              ReadMemory(address, out check);              ReadMemory(address, out check);
177              if (check == value) return true;              if (check == value) return true;
# Line 185  namespace Sojaner.MemoryScanner.MemoryPr Line 185  namespace Sojaner.MemoryScanner.MemoryPr
185              int bytesWritten;              int bytesWritten;
186              byte[] bitData = BitConverter.GetBytes(value);              byte[] bitData = BitConverter.GetBytes(value);
187              provider.WriteProcessMemory(address, bitData, out bytesWritten);              provider.WriteProcessMemory(address, bitData, out bytesWritten);
188                
189              uint check = 0;              uint check = 0;
190              ReadMemory(address, out check);              ReadMemory(address, out check);
191              if (check == value) return true;              if (check == value) return true;
# Line 199  namespace Sojaner.MemoryScanner.MemoryPr Line 199  namespace Sojaner.MemoryScanner.MemoryPr
199              int bytesWritten;              int bytesWritten;
200              byte[] bitData = BitConverter.GetBytes(value);              byte[] bitData = BitConverter.GetBytes(value);
201              provider.WriteProcessMemory(address, bitData, out bytesWritten);              provider.WriteProcessMemory(address, bitData, out bytesWritten);
202                
203              int check = 0;              int check = 0;
204              ReadMemory(address, out check);              ReadMemory(address, out check);
205              if (check == value) return true;              if (check == value) return true;
# Line 213  namespace Sojaner.MemoryScanner.MemoryPr Line 213  namespace Sojaner.MemoryScanner.MemoryPr
213              int bytesWritten;              int bytesWritten;
214              byte[] bitData = BitConverter.GetBytes(value);              byte[] bitData = BitConverter.GetBytes(value);
215              provider.WriteProcessMemory(address, bitData, out bytesWritten);              provider.WriteProcessMemory(address, bitData, out bytesWritten);
216                
217              ulong check = 0;              ulong check = 0;
218              ReadMemory(address, out check);              ReadMemory(address, out check);
219              if (check == value) return true;              if (check == value) return true;
# Line 227  namespace Sojaner.MemoryScanner.MemoryPr Line 227  namespace Sojaner.MemoryScanner.MemoryPr
227              int bytesWritten;              int bytesWritten;
228              byte[] bitData = BitConverter.GetBytes(value);              byte[] bitData = BitConverter.GetBytes(value);
229              provider.WriteProcessMemory(address, bitData, out bytesWritten);              provider.WriteProcessMemory(address, bitData, out bytesWritten);
230                
231              long check = 0;              long check = 0;
232              ReadMemory(address, out check);              ReadMemory(address, out check);
233              if (check == value) return true;              if (check == value) return true;
# Line 241  namespace Sojaner.MemoryScanner.MemoryPr Line 241  namespace Sojaner.MemoryScanner.MemoryPr
241          public virtual bool ReadMemory(int address, out byte value)          public virtual bool ReadMemory(int address, out byte value)
242          {          {
243              value = 0;              value = 0;
244               if (!EnsureProviderIsOpen()) { return false; }              if (!EnsureProviderIsOpen()) { return false; }
245              try              try
246              {   int bytesReadSize;              {
247                    int bytesReadSize;
248                  byte[] bitData;                  byte[] bitData;
249                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
250                  value = bitData[0];                  value = bitData[0];
251                    
252                  return true;                  return true;
253              }              }
254              catch              catch
# Line 263  namespace Sojaner.MemoryScanner.MemoryPr Line 264  namespace Sojaner.MemoryScanner.MemoryPr
264              value = 0;              value = 0;
265              if (!EnsureProviderIsOpen()) { return false; }              if (!EnsureProviderIsOpen()) { return false; }
266              try              try
267              {                {
268                  int bytesReadSize;                  int bytesReadSize;
269                  byte[] bitData;                  byte[] bitData;
270                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
271                  value = Convert.ToSByte(bitData[0]);                  value = Convert.ToSByte(bitData[0]);
272                    
273                  return true;                  return true;
274              }              }
275              catch              catch
# Line 289  namespace Sojaner.MemoryScanner.MemoryPr Line 290  namespace Sojaner.MemoryScanner.MemoryPr
290                  byte[] bitData;                  byte[] bitData;
291                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
292                  value = BitConverter.ToUInt16(bitData, 0);                  value = BitConverter.ToUInt16(bitData, 0);
293                    
294                  return true;                  return true;
295              }              }
296              catch              catch
# Line 310  namespace Sojaner.MemoryScanner.MemoryPr Line 311  namespace Sojaner.MemoryScanner.MemoryPr
311                  byte[] bitData;                  byte[] bitData;
312                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
313                  value = BitConverter.ToInt16(bitData, 0);                  value = BitConverter.ToInt16(bitData, 0);
314                    
315                  return true;                  return true;
316              }              }
317              catch              catch
# Line 331  namespace Sojaner.MemoryScanner.MemoryPr Line 332  namespace Sojaner.MemoryScanner.MemoryPr
332                  byte[] bitData;                  byte[] bitData;
333                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
334                  value = BitConverter.ToUInt32(bitData, 0);                  value = BitConverter.ToUInt32(bitData, 0);
335                    
336                  return true;                  return true;
337              }              }
338              catch              catch
# Line 352  namespace Sojaner.MemoryScanner.MemoryPr Line 353  namespace Sojaner.MemoryScanner.MemoryPr
353                  byte[] bitData;                  byte[] bitData;
354                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
355                  value = BitConverter.ToInt32(bitData, 0);                  value = BitConverter.ToInt32(bitData, 0);
356                    
357                  return true;                  return true;
358              }              }
359              catch              catch
# Line 373  namespace Sojaner.MemoryScanner.MemoryPr Line 374  namespace Sojaner.MemoryScanner.MemoryPr
374                  byte[] bitData;                  byte[] bitData;
375                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
376                  value = BitConverter.ToUInt64(bitData, 0);                  value = BitConverter.ToUInt64(bitData, 0);
377                    
378                  return true;                  return true;
379              }              }
380              catch              catch
# Line 394  namespace Sojaner.MemoryScanner.MemoryPr Line 395  namespace Sojaner.MemoryScanner.MemoryPr
395                  byte[] bitData;                  byte[] bitData;
396                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
397                  value = BitConverter.ToInt64(bitData, 0);                  value = BitConverter.ToInt64(bitData, 0);
398                    
399                  return true;                  return true;
400              }              }
401              catch              catch
# Line 415  namespace Sojaner.MemoryScanner.MemoryPr Line 416  namespace Sojaner.MemoryScanner.MemoryPr
416              try { provider.ReadFirstNonZeroByte(MemoryAddress, bytesToRead, out address); return true; }              try { provider.ReadFirstNonZeroByte(MemoryAddress, bytesToRead, out address); return true; }
417              catch { address = 0x00; return false; }              catch { address = 0x00; return false; }
418          }          }
419          #endregion                #endregion
420          #region public virtual void ReadProcessMemory(int MemoryAddress, int bytesToRead, out int bytesRead, out byte[] data)          #region public virtual void ReadProcessMemory(int MemoryAddress, int bytesToRead, out int bytesRead, out byte[] data)
421          public virtual void ReadProcessMemory(int MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)          public virtual void ReadProcessMemory(int MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
422          {          {
# Line 461  namespace Sojaner.MemoryScanner.MemoryPr Line 462  namespace Sojaner.MemoryScanner.MemoryPr
462          #endregion          #endregion
463      }      }
464      #endregion      #endregion
465    }
     #region MemoryScanner-r204  
     namespace r204  
     {  
         #region public abstract class BaseMemoryProvider  
         public abstract class BaseMemoryProvider :  
             IPatchMemory,  
             IReadMemory,  
             IAcceptsProcess<Process>,  
             IAcceptsPlugin<IConfigPlugin>,  
             IMemoryReader,  
             IMemoryWriter,  
             IFileWriter  
         {  
             private Sojaner.MemoryScanner.r204.ProcessMemoryReader provider;  
             public BaseMemoryProvider() { this.AcceptedPlugin = null; this.AcceptedProcess = null; isClosed = true; isOpen = false; }  
             public BaseMemoryProvider(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }  
             public BaseMemoryProvider(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }  
             public BaseMemoryProvider(IAcceptsProcessAndConfig config) : this() { this.AcceptedPlugin = config.AcceptedPlugin; this.AcceptedProcess = config.AcceptedProcess; }  
   
   
             private bool isOpen { get; set; }  
             private bool isClosed { get; set; }  
   
             #region Open/Close Provider  
             #region public virtual void OpenProvider()  
             public virtual void OpenProvider()  
             {  
                 if (isOpen)  
                 {  
                     logger.Warn.WriteLine("Provider has already been opened.");  
                     return;  
                 }  
                 try  
                 {  
                     provider = new Sojaner.MemoryScanner.r204.ProcessMemoryReader();  
                     provider.ReadProcess = this.AcceptedProcess;  
                     if (provider.ReadProcess == null) { logger.Error.WriteLine("{0}.OpenProvider() Could not attach to process: {1}", "", this.GetType().Name, this.AcceptedProcess.ToString()); return; }  
                     provider.OpenProcess();  
                     isOpen = true;  
                     isClosed = false;  
                 }  
                 catch (Exception ex)  
                 {  
                     logger.Error.WriteLine("Failed to open provider: {0}{1}", System.Environment.NewLine, ex.ToString());  
                     isOpen = false;  
                     isClosed = true;  
                 }  
             }  
             #endregion  
             #region public virtual void CloseProvider()  
             public virtual void CloseProvider()  
             {  
                 if (isClosed)  
                 {  
                     logger.Warn.WriteLine("Provider has already been closed.");  
                     return;  
                 }  
                 if (!isOpen)  
                 {  
                     logger.Warn.WriteLine("Provider cannot be closed, it was never opened...attempting to open provider.");  
                     OpenProvider();  
                     if (!isOpen)  
                     {  
                         logger.Warn.WriteLine("Could not open provider");  
                         return;  
                     }  
                 }  
                 try  
                 {  
                     //logger.VerboseDebug.WriteLine("CloseProvider(): System.Environment.StackTrace: {0}{1}", System.Environment.NewLine, System.Environment.StackTrace);  
                     if (provider == null) return;  
                     provider.CloseHandle();  
                     //provider = null; // free any memory associated with the provider  
                     isClosed = true;  
                     isOpen = false;  
                 }  
                 catch (Exception ex)  
                 {  
                     logger.Error.WriteLine("Failed to close provider: {0}{1}", System.Environment.NewLine, ex.ToString());  
                     isClosed = false;  
                     if (isOpen)  
                     {  
                         throw new Exception("Provider is failed to close and still open.");  
                     }  
                 }  
             }  
             #endregion  
             #endregion  
   
             #region  IAcceptsProcess<Process> Members  
             public Process AcceptedProcess { get; set; }  
             #endregion  
             #region IAcceptsPlugin<IConfigPlugin> Members  
             public IConfigPlugin AcceptedPlugin { get; set; }  
             #endregion  
             #region EnsureProviderIsOpen methods : log and/or throw errors  
             private bool EnsureProviderIsOpen() { return EnsureProviderIsOpenOrThrowError(); }  
             private bool EnsureProviderIsOpenOrLogError() { return EnsureProviderIsOpenOrThrowOrLogError(false, true); }  
             private bool EnsureProviderIsOpenOrThrowError() { return EnsureProviderIsOpenOrThrowOrLogError(true, true); }  
             private bool EnsureProviderIsOpenOrThrowOrLogError(bool ThrowError, bool LogError)  
             {  
                 if (!isOpen)  
                 {  
                     try { throw new Exception("Memory operation could not be completed because the provider is not open"); }  
                     catch (Exception ex)  
                     {  
                         if (LogError)  
                             logger.Error.WriteLine(ex.ToString());  
                         if (ThrowError)  
                             throw ex;  
                         return false;  
                     }  
                 }  
                 return true;  
             }  
             #endregion  
   
             #region IPatchMemory members  
             #region public virtual bool PatchMemory(int address, byte value)  
             public virtual bool PatchMemory(int address, byte value)  
             {  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 int bytesWritten;  
                 byte[] bitData = BitConverter.GetBytes(value);  
                 provider.WriteProcessMemory(address, bitData, out bytesWritten);  
                 byte check = 0;  
                 ReadMemory(address, out check);  
                 if (check == value) return true;  
                 return false;  
             }  
             #endregion  
             #region public virtual bool PatchMemory(int address, sbyte value)  
             public virtual bool PatchMemory(int address, sbyte value)  
             {  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 int bytesWritten;  
                 byte[] bitData = BitConverter.GetBytes(value);  
                 provider.WriteProcessMemory(address, bitData, out bytesWritten);  
                 sbyte check = 0;  
                 ReadMemory(address, out check);  
                 if (check == value) return true;  
                 return false;  
             }  
             #endregion  
             #region public virtual bool PatchMemory(int address, ushort value)  
             public virtual bool PatchMemory(int address, ushort value)  
             {  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 int bytesWritten;  
                 byte[] bitData = BitConverter.GetBytes(value);  
                 provider.WriteProcessMemory(address, bitData, out bytesWritten);  
   
                 ushort check = 0;  
                 ReadMemory(address, out check);  
                 if (check == value) return true;  
                 return false;  
             }  
             #endregion  
             #region public virtual bool PatchMemory(int address, short value)  
             public virtual bool PatchMemory(int address, short value)  
             {  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 int bytesWritten;  
                 byte[] bitData = BitConverter.GetBytes(value);  
                 provider.WriteProcessMemory(address, bitData, out bytesWritten);  
   
                 short check = 0;  
                 ReadMemory(address, out check);  
                 if (check == value) return true;  
                 return false;  
             }  
             #endregion  
             #region public virtual bool PatchMemory(int address, uint value)  
             public virtual bool PatchMemory(int address, uint value)  
             {  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 int bytesWritten;  
                 byte[] bitData = BitConverter.GetBytes(value);  
                 provider.WriteProcessMemory(address, bitData, out bytesWritten);  
   
                 uint check = 0;  
                 ReadMemory(address, out check);  
                 if (check == value) return true;  
                 return false;  
             }  
             #endregion  
             #region public virtual bool PatchMemory(int address, int value)  
             public virtual bool PatchMemory(int address, int value)  
             {  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 int bytesWritten;  
                 byte[] bitData = BitConverter.GetBytes(value);  
                 provider.WriteProcessMemory(address, bitData, out bytesWritten);  
   
                 int check = 0;  
                 ReadMemory(address, out check);  
                 if (check == value) return true;  
                 return false;  
             }  
             #endregion  
             #region public virtual bool PatchMemory(int address, ulong value)  
             public virtual bool PatchMemory(int address, ulong value)  
             {  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 int bytesWritten;  
                 byte[] bitData = BitConverter.GetBytes(value);  
                 provider.WriteProcessMemory(address, bitData, out bytesWritten);  
   
                 ulong check = 0;  
                 ReadMemory(address, out check);  
                 if (check == value) return true;  
                 return false;  
             }  
             #endregion  
             #region public virtual bool PatchMemory(int address, long value)  
             public virtual bool PatchMemory(int address, long value)  
             {  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 int bytesWritten;  
                 byte[] bitData = BitConverter.GetBytes(value);  
                 provider.WriteProcessMemory(address, bitData, out bytesWritten);  
   
                 long check = 0;  
                 ReadMemory(address, out check);  
                 if (check == value) return true;  
                 return false;  
             }  
             #endregion  
             #endregion  
   
             #region IReadMemory members  
             #region public virtual bool ReadMemory(int address, out byte value)  
             public virtual bool ReadMemory(int address, out byte value)  
             {  
                 value = 0;  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 try  
                 {  
                     int bytesReadSize;  
                     byte[] bitData;  
                     provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                     value = bitData[0];  
   
                     return true;  
                 }  
                 catch  
                 {  
                     value = 0x00;  
                     return false;  
                 }  
             }  
             #endregion  
             #region public virtual bool ReadMemory(int address, out sbyte value)  
             public virtual bool ReadMemory(int address, out sbyte value)  
             {  
                 value = 0;  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 try  
                 {  
                     int bytesReadSize;  
                     byte[] bitData;  
                     provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                     value = Convert.ToSByte(bitData[0]);  
   
                     return true;  
                 }  
                 catch  
                 {  
                     value = 0x00;  
                     return false;  
                 }  
             }  
             #endregion  
             #region public virtual bool ReadMemory(int address, out ushort value)  
             public virtual bool ReadMemory(int address, out ushort value)  
             {  
                 value = 0;  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 try  
                 {  
                     int bytesReadSize;  
                     byte[] bitData;  
                     provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                     value = BitConverter.ToUInt16(bitData, 0);  
   
                     return true;  
                 }  
                 catch  
                 {  
                     value = 0x00;  
                     return false;  
                 }  
             }  
             #endregion  
             #region public virtual bool ReadMemory(int address, out short value)  
             public virtual bool ReadMemory(int address, out short value)  
             {  
                 value = 0;  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 try  
                 {  
                     int bytesReadSize;  
                     byte[] bitData;  
                     provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                     value = BitConverter.ToInt16(bitData, 0);  
   
                     return true;  
                 }  
                 catch  
                 {  
                     value = 0x00;  
                     return false;  
                 }  
             }  
             #endregion  
             #region public virtual bool ReadMemory(int address, out uint value)  
             public virtual bool ReadMemory(int address, out uint value)  
             {  
                 value = 0;  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 try  
                 {  
                     int bytesReadSize;  
                     byte[] bitData;  
                     provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                     value = BitConverter.ToUInt32(bitData, 0);  
   
                     return true;  
                 }  
                 catch  
                 {  
                     value = 0x00;  
                     return false;  
                 }  
             }  
             #endregion  
             #region public virtual bool ReadMemory(int address, out int value)  
             public virtual bool ReadMemory(int address, out int value)  
             {  
                 value = 0;  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 try  
                 {  
                     int bytesReadSize;  
                     byte[] bitData;  
                     provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                     value = BitConverter.ToInt32(bitData, 0);  
   
                     return true;  
                 }  
                 catch  
                 {  
                     value = 0x00;  
                     return false;  
                 }  
             }  
             #endregion  
             #region public virtual bool ReadMemory(int address, out ulong value)  
             public virtual bool ReadMemory(int address, out ulong value)  
             {  
                 value = 0;  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 try  
                 {  
                     int bytesReadSize;  
                     byte[] bitData;  
                     provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                     value = BitConverter.ToUInt64(bitData, 0);  
   
                     return true;  
                 }  
                 catch  
                 {  
                     value = 0x00;  
                     return false;  
                 }  
             }  
             #endregion  
             #region public virtual bool ReadMemory(int address, out long value)  
             public virtual bool ReadMemory(int address, out long value)  
             {  
                 value = 0;  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 try  
                 {  
                     int bytesReadSize;  
                     byte[] bitData;  
                     provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                     value = BitConverter.ToInt64(bitData, 0);  
   
                     return true;  
                 }  
                 catch  
                 {  
                     value = 0x00;  
                     return false;  
                 }  
             }  
             #endregion  
             #endregion  
   
             #region IMemoryReader members  
             #region public virtual bool ReadFirstNonZeroByte(int MemoryAddress, uint bytesToRead, out int address)  
             public virtual bool ReadFirstNonZeroByte(int MemoryAddress, uint bytesToRead, out int address)  
             {  
                 address = 0;  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 try { provider.ReadFirstNonZeroByte(MemoryAddress, bytesToRead, out address); return true; }  
                 catch { address = 0x00; return false; }  
             }  
             #endregion  
             #region public virtual void ReadProcessMemory(int MemoryAddress, int bytesToRead, out int bytesRead, out byte[] data)  
             public virtual void ReadProcessMemory(int MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)  
             {  
                 bytesRead = 0x00;  
                 data = new byte[] { };  
                 if (!EnsureProviderIsOpen()) { return; }  
                 try { provider.ReadProcessMemory(MemoryAddress, bytesToRead, out bytesRead, out data); }  
                 catch { bytesRead = 0x00; data = new byte[] { }; }  
             }  
             #endregion  
             #region IMemoryWriter members  
             #region public virtual void WriteProcessMemory(int MemoryAddress, byte byteToWrite, out int bytesWritten)  
             public virtual void WriteProcessMemory(int MemoryAddress, byte byteToWrite, out int bytesWritten)  
             {  
                 bytesWritten = 0;  
                 if (!EnsureProviderIsOpen()) { return; }  
                 try { provider.WriteProcessMemory(MemoryAddress, new byte[] { byteToWrite }, out bytesWritten); }  
                 catch { bytesWritten = 0x00; }  
             }  
             #endregion  
             #region public virtual void WriteProcessMemory(int MemoryAddress, byte[] bytesToWrite, out int bytesWritten)  
             public virtual void WriteProcessMemory(int MemoryAddress, byte[] bytesToWrite, out int bytesWritten)  
             {  
                 bytesWritten = 0;  
                 if (!EnsureProviderIsOpen()) { return; }  
                 try { provider.WriteProcessMemory(MemoryAddress, bytesToWrite, out bytesWritten); }  
                 catch { bytesWritten = 0x00; }  
             }  
             #endregion  
             #endregion  
             #endregion  
             #region IFileWriter members  
             #region  public virtual bool WriteProcessMemoryToFile(string filename, int MemoryAddress, uint bytesToRead, out int bytesRead)  
             public virtual bool WriteProcessMemoryToFile(string filename, int MemoryAddress, uint bytesToRead, out int bytesRead)  
             {  
                 bytesRead = 0;  
                 if (!EnsureProviderIsOpen()) { return false; }  
                 try { provider.WriteProcessMemoryToFile(filename, MemoryAddress, bytesToRead, out bytesRead); return true; }  
                 catch  
                 { bytesRead = 0x00; return false; }  
             }  
             #endregion  
             #endregion  
         }  
         #endregion  
     }  
     #endregion  
 }  

Legend:
Removed from v.254  
changed lines
  Added in v.255

  ViewVC Help
Powered by ViewVC 1.1.22