ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/RomCheater/trunk/Win32/Sojaner.MemoryScanner/MemoryScanner.cs
(Generate patch)

Comparing trunk/Win32/Sojaner.MemoryScanner/MemoryScanner.cs (file contents):
Revision 408 by william, Thu Jun 21 18:10:21 2012 UTC vs.
Revision 409 by william, Thu Jun 21 20:02:40 2012 UTC

# Line 88 | Line 88 | namespace Sojaner.MemoryScanner
88          private Process m_ReadProcess = null;
89  
90          //SafeWaitHandle handle;
91 <        private static IntPtr m_hProcess = IntPtr.Zero;
92 <
91 >        private static IntPtr handle = IntPtr.Zero;
92 >        SafeWaitHandle m_hProcess;
93          public void OpenProcess()
94          {
95              try
# Line 104 | Line 104 | namespace Sojaner.MemoryScanner
104                      | ProcessAccessType.PROCESS_VM_WRITE
105                      | ProcessAccessType.PROCESS_VM_OPERATION;
106                  //m_hProcess = ProcessMemoryReaderApi.OpenProcess((uint)access, 1, (uint)m_ReadProcess.Id);
107 <               m_hProcess = ProcessMemoryReaderApi.OpenProcess((uint)access, 1, (uint)m_ReadProcess.Id);
107 >                handle = ProcessMemoryReaderApi.OpenProcess((uint)access, 1, (uint)m_ReadProcess.Id);
108 >                m_hProcess = new SafeWaitHandle(handle, false);
109              }
110              catch (SEHException ex)
111              {
# Line 123 | Line 124 | namespace Sojaner.MemoryScanner
124          {
125              try
126              {
127 <                SafeWaitHandle handle = new SafeWaitHandle(m_ReadProcess.Handle, false);
128 <                if (handle.IsInvalid) { return; }
129 <                if (handle.IsClosed) { return; }
130 <                handle.Close();
131 <                handle = null;
132 <                //m_hProcess = IntPtr.Zero;
127 >                //if (handle.IsInvalid) { return; }
128 >                //if (handle.IsClosed) { return; }
129 >                m_hProcess.Close();
130 >                m_hProcess.Dispose();
131 >                m_hProcess = null;
132 >                handle = IntPtr.Zero;
133 >                m_ReadProcess = null;
134                  //string stack_trace = System.Environment.StackTrace;
135                  //int iRetValue;
136                  //iRetValue = ProcessMemoryReaderApi.CloseHandle(m_hProcess);
# Line 297 | Line 299 | namespace Sojaner.MemoryScanner
299              uint size = 1024 * 128;
300              for (uint j = MemoryAddress; j < bytesToRead; j += size)
301              {
302 <                ProcessMemoryChunk mem = new ProcessMemoryChunk(m_ReadProcess, (IntPtr)j, (int)size);
303 <                byte[] bigMem = mem.Read();
304 <                if (this.OnBytesRead != null)
305 <                    this.OnBytesRead.Invoke(new OnBytesReadEventArgs(this, UserState, bigMem, j, bytesToRead));
306 <                bigMem = null;
302 >                using (ProcessMemoryChunk mem = new ProcessMemoryChunk(m_ReadProcess, (IntPtr)j, (int)size))
303 >                {
304 >                    byte[] bigMem = mem.Read();
305 >                    if (this.OnBytesRead != null)
306 >                        this.OnBytesRead.Invoke(new OnBytesReadEventArgs(this, UserState, bigMem, j, bytesToRead));
307 >                    bigMem = null;
308 >                }
309              }
306 –            
310          }
311          public void ReadProcessMemoryAtOnce(uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
312          {
# Line 313 | Line 316 | namespace Sojaner.MemoryScanner
316              List<byte> buffer_list = new List<byte>();
317              for (uint j = MemoryAddress; j < bytesToRead; j += size)
318              {
319 <                ProcessMemoryChunk mem = new ProcessMemoryChunk(m_ReadProcess, (IntPtr)j, (int)size);
320 <                byte[] bigMem = mem.Read();
321 <                foreach (byte b in bigMem) { buffer_list.Add(b); }
322 <                bigMem = null;
319 >                using (ProcessMemoryChunk mem = new ProcessMemoryChunk(m_ReadProcess, (IntPtr)j, (int)size))
320 >                {
321 >                    byte[] bigMem = mem.Read();
322 >                    foreach (byte b in bigMem) { buffer_list.Add(b); }
323 >                    bigMem = null;
324 >                }
325              }
326              bytesRead = buffer_list.Count;
327              data = new byte[bytesToRead];
# Line 363 | Line 368 | namespace Sojaner.MemoryScanner
368                          buffer_list.RemoveAt(buffer_list.Count-1);
369                      }
370  
371 <                    ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_ReadProcess.Handle, (IntPtr)_MemoryAddress, buffer, alignment, out _bytesRead);
371 >                    ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(handle, (IntPtr)_MemoryAddress, buffer, alignment, out _bytesRead);
372                      int LastError = Marshal.GetLastWin32Error();
373                      if (LastError != ResultWin32.ERROR_SUCCESS)
374                      {
# Line 415 | Line 420 | namespace Sojaner.MemoryScanner
420                  {
421                      UIntPtr _ptrBytesWritten = UIntPtr.Zero;
422                      byte[] buffer = new byte[] { bytesToWrite[i] };
423 <                    ProcessMemoryReaderApi.WriteProcessMemory(m_ReadProcess.Handle, (IntPtr)_MemoryAddress, buffer, (uint)buffer.Length, out _ptrBytesWritten);
423 >                    ProcessMemoryReaderApi.WriteProcessMemory(handle, (IntPtr)_MemoryAddress, buffer, (uint)buffer.Length, out _ptrBytesWritten);
424                      _MemoryAddress++;
425                      _bytesWritten++;
426                  }
# Line 521 | Line 526 | namespace Sojaner.MemoryScanner
526          {
527              byte[] bitData = BitConverter.GetBytes(value);
528              UIntPtr ptrBytesWritten;
529 <            ProcessMemoryReaderApi.WriteProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
529 >            ProcessMemoryReaderApi.WriteProcessMemory(handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
530              if (ptrBytesWritten.ToUInt32() == 0)
531                  return false;
532              byte check = 0;
# Line 535 | Line 540 | namespace Sojaner.MemoryScanner
540          {
541              byte[] bitData = BitConverter.GetBytes(value);
542              UIntPtr ptrBytesWritten;
543 <            ProcessMemoryReaderApi.WriteProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
543 >            ProcessMemoryReaderApi.WriteProcessMemory(handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
544              if (ptrBytesWritten.ToUInt32() == 0)
545                  return false;
546              sbyte check = 0;
# Line 549 | Line 554 | namespace Sojaner.MemoryScanner
554          {
555              byte[] bitData = BitConverter.GetBytes(value);
556              UIntPtr ptrBytesWritten;
557 <            ProcessMemoryReaderApi.WriteProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
557 >            ProcessMemoryReaderApi.WriteProcessMemory(handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
558              if (ptrBytesWritten.ToUInt32() == 0)
559                  return false;
560              ushort check = 0;
# Line 563 | Line 568 | namespace Sojaner.MemoryScanner
568          {          
569              byte[] bitData = BitConverter.GetBytes(value);
570              UIntPtr ptrBytesWritten;
571 <            ProcessMemoryReaderApi.WriteProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
571 >            ProcessMemoryReaderApi.WriteProcessMemory(handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
572              if (ptrBytesWritten.ToUInt32() == 0)
573                  return false;
574              short check = 0;
# Line 577 | Line 582 | namespace Sojaner.MemoryScanner
582          {
583              byte[] bitData = BitConverter.GetBytes(value);
584              UIntPtr ptrBytesWritten;
585 <            ProcessMemoryReaderApi.WriteProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
585 >            ProcessMemoryReaderApi.WriteProcessMemory(handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
586              if (ptrBytesWritten.ToUInt32() == 0)
587                  return false;
588              uint check = 0;
# Line 591 | Line 596 | namespace Sojaner.MemoryScanner
596          {
597              byte[] bitData = BitConverter.GetBytes(value);
598              UIntPtr ptrBytesWritten;
599 <            ProcessMemoryReaderApi.WriteProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
599 >            ProcessMemoryReaderApi.WriteProcessMemory(handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
600              if (ptrBytesWritten.ToUInt32() == 0)
601                  return false;
602              int check = 0;
# Line 605 | Line 610 | namespace Sojaner.MemoryScanner
610          {
611              byte[] bitData = BitConverter.GetBytes(value);
612              UIntPtr ptrBytesWritten;
613 <            ProcessMemoryReaderApi.WriteProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
613 >            ProcessMemoryReaderApi.WriteProcessMemory(handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
614              if (ptrBytesWritten.ToUInt32() == 0)
615                  return false;
616              ulong check = 0;
# Line 619 | Line 624 | namespace Sojaner.MemoryScanner
624          {
625              byte[] bitData = BitConverter.GetBytes(value);
626              UIntPtr ptrBytesWritten;
627 <            ProcessMemoryReaderApi.WriteProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
627 >            ProcessMemoryReaderApi.WriteProcessMemory(handle, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
628              if (ptrBytesWritten.ToUInt32() == 0)
629                  return false;
630              long check = 0;
# Line 640 | Line 645 | namespace Sojaner.MemoryScanner
645                  int bytesRead;
646                  uint size = sizeof(byte);
647                  byte[] bitData = new byte[size];
648 <                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, size, out bytesRead);
648 >                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(handle, (IntPtr)address, bitData, size, out bytesRead);
649                  if (bytesRead == 0)
650                      return false;
651                  value = bitData[0];
# Line 662 | Line 667 | namespace Sojaner.MemoryScanner
667                  int bytesRead;
668                  uint size = sizeof(sbyte);
669                  byte[] bitData = new byte[size];
670 <                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, size, out bytesRead);
670 >                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(handle, (IntPtr)address, bitData, size, out bytesRead);
671                  if (bytesRead == 0)
672                      return false;
673                  value = Convert.ToSByte(bitData[0]);
# Line 684 | Line 689 | namespace Sojaner.MemoryScanner
689                  int bytesRead;
690                  uint size = sizeof(ushort);
691                  byte[] bitData = new byte[size];
692 <                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, size, out bytesRead);
692 >                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(handle, (IntPtr)address, bitData, size, out bytesRead);
693                  if (bytesRead == 0)
694                      return false;
695                  value = BitConverter.ToUInt16(bitData, 0);
# Line 706 | Line 711 | namespace Sojaner.MemoryScanner
711                  int bytesRead;
712                  uint size = sizeof(short);
713                  byte[] bitData = new byte[size];
714 <                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, size, out bytesRead);
714 >                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(handle, (IntPtr)address, bitData, size, out bytesRead);
715                  if (bytesRead == 0)
716                      return false;
717                  value = BitConverter.ToInt16(bitData, 0);
# Line 728 | Line 733 | namespace Sojaner.MemoryScanner
733                  int bytesRead;
734                  uint size = sizeof(uint);
735                  byte[] bitData = new byte[size];
736 <                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, size, out bytesRead);
736 >                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(handle, (IntPtr)address, bitData, size, out bytesRead);
737                  if (bytesRead == 0)
738                      return false;
739                  value = BitConverter.ToUInt32(bitData, 0);
# Line 750 | Line 755 | namespace Sojaner.MemoryScanner
755                  int bytesRead;
756                  uint size = sizeof(int);
757                  byte[] bitData = new byte[size];
758 <                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, size, out bytesRead);
758 >                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(handle, (IntPtr)address, bitData, size, out bytesRead);
759                  if (bytesRead == 0)
760                      return false;
761                  value = BitConverter.ToInt32(bitData, 0);
# Line 772 | Line 777 | namespace Sojaner.MemoryScanner
777                  int bytesRead;
778                  uint size = sizeof(ulong);
779                  byte[] bitData = new byte[size];
780 <                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, size, out bytesRead);
780 >                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(handle, (IntPtr)address, bitData, size, out bytesRead);
781                  if (bytesRead == 0)
782                      return false;
783                  value = BitConverter.ToUInt64(bitData, 0);
# Line 794 | Line 799 | namespace Sojaner.MemoryScanner
799                  int bytesRead;
800                  uint size = sizeof(long);
801                  byte[] bitData = new byte[size];
802 <                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_ReadProcess.Handle, (IntPtr)address, bitData, size, out bytesRead);
802 >                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(handle, (IntPtr)address, bitData, size, out bytesRead);
803                  if (bytesRead == 0)
804                      return false;
805                  value = BitConverter.ToInt64(bitData, 0);

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines